GitScrum Sprints MCP for AI. Know project progress, without opening a dashboard.
Works with every AI agent you already use
…and any MCP-compatible client








Connect to your AI in seconds.
GitScrum Sprints manages your entire agile development lifecycle through an AI agent. It lets you plan sprints, track user stories from epic to task, and generate detailed performance reports on demand.
You can monitor velocity trends, review burndown charts, and manage multiple project backlogs without leaving your chat window.
What your AI can do
All sprints
Retrieves a list of all active and past sprints across every workspace in your account.
Create user story
Adds a new user story to the project backlog.
List epics
Fetches all epics associated with a specific project or portfolio.
Create new sprints or review existing ones with specific date ranges.
List, browse, and create user stories and epics to map out future development work.
Retrieve all tasks within a specific sprint, filtering them by their current status (To Do, In Progress, Done).
Access detailed Key Performance Indicators and velocity reports for any completed or active sprint.
Pull data needed for burndown, burnup, and distribution charts for deep-dive analysis.
Ask an AI about this
Waiting for input…
GitScrum Sprints: 15 Tools for Agile Tracking
These tools let you manage every stage of the agile process—from listing epics to calculating complex sprint KPIs—all through natural language prompts.
Make your AI actually useful.
Add this MCP to Claude, Cursor, or Windsurf and your AI stops guessing. It gets real tools to look things up, take action, and handle the stuff you keep doing by hand.
Start using GitScrum Sprints on VinkiusAll Sprints
Retrieves a list of all active and past sprints across every workspace in your account.
Create User Story
Adds a new user story to the project backlog.
List Epics
Fetches all epics associated with a specific project or portfolio.
Create Sprint
Sets up a brand new sprint cycle with defined start and end dates.
Get Sprint
Pulls detailed information for one specific sprint ID.
Sprint Kpis
Calculates and returns a set of key performance indicators for the current sprint cycle.
List Sprints
Gets a list of sprints that belong to a single, defined project.
Sprint Metrics
Provides deep, detailed statistics covering effort, type distribution, and task...
Sprint Progress
Calculates the current completion percentage of an active sprint against its goal.
Sprint Reports
Generates comprehensive reports, including data needed for burndown and burnup...
Sprint Stats
Gathers general statistical summaries about a specific sprint's performance history.
Update Sprint
Modifies the date range or name of an existing sprint cycle.
Get Task
Retrieves granular details about a single task using its unique identifier.
List Tasks
Shows tasks in a project, allowing you to filter them by specific sprints and...
List User Stories
Lists all user stories currently available within the project backlog.
Security and governance baked right in.
Pick your AI client below to get set up. Just create a Vinkius account, subscribe, and you're instantly up and running. We handle the entire backend infrastructure, delivering out-of-the-box support for HTTPS Streamable, SSE, and OAuth2—zero messy routing required.
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
Make Your AI Do More
Start with GitScrum Sprints, then connect any of our 5,100+ other servers whenever your AI needs more. One click, no limits.
- Use this MCP plus 5,100+ 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
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
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 connection provides 15 powerful capabilities that interface natively with Claude, ChatGPT, Cursor, and other compatible AI platforms. No middleware. No custom integration required.
The status check: a manual process of clicking and copying
Today, checking project health means opening GitScrum. You jump to the main board, then open the backlog view to check for new stories. Next, you navigate to the reports section just to see if the team hit their target velocity last cycle. Then, because you're unsure about the scope, you have to manually list all tasks and filter them by status (To Do/Done). It takes five minutes of clicking, three different tabs, and half a dozen copy-pasted numbers.
With this MCP, your agent handles it all in one go. You just ask: 'What's the progress on our payments feature?' The agent instantly combines information from `list_epics`, checks current status with `sprint_progress`, and reports back what you need without you ever leaving your chat window.
Understanding sprint cycles with GitScrum Sprints
Before, if the team needed to adjust a scope or extend a deadline, someone had to go into the settings and manually update the date range for the entire cycle. If they wanted to start fresh, they had to click 'New Sprint,' select the dates, and then remember to populate all the initial user stories.
Now, you can use `create_sprint` and define the parameters with a single prompt. The agent manages the lifecycle, allowing you to update or inspect any sprint using `get_sprint` while ensuring your records stay clean and accurate.
What your AI can actually do with this
Forget navigating separate dashboards just to see if the team hit their goal. This MCP connects directly to GitScrum, giving your AI agent a single source of truth for all things development progress. You ask it about sprint status or velocity, and it synthesizes data across every connected workspace instantly.
It aggregates complex metrics—like burnup charts and task completion rates—and gives you plain English answers, instead of spreadsheets full of raw numbers. By connecting the GitScrum Sprints MCP via Vinkius, your agent gains instant visibility into everything from initial epic creation to final sprint updates, letting you focus on product strategy, not data gathering.
019d8441-9748-7240-9d94-e19fd1606adf Here's how it actually works
The bottom line is: the MCP translates complex agile data into simple conversations with your AI client.
Subscribe to the GitScrum Sprints MCP from Vinkius. Then, enter your required GitScrum API token and company slug into the connection settings.
Give a natural language prompt to your AI client, asking it to review sprint progress or analyze velocity trends for a specific project.
Your agent pulls all necessary data—like task status or KPI metrics—and delivers structured, actionable insights directly back to you.
Who is this actually for?
Anyone who has spent too long copy-pasting status updates or clicking through six different project dashboards to answer one question. This is for the Product Owner who needs to prove roadmap value, and the Scrum Master who runs daily standups without needing a dedicated reporting dashboard.
Running retrospectives or daily stands. You use this MCP to pull live sprint KPIs and compare current progress against historical team performance.
Defining the next quarter's roadmap. You rely on it to list epics, create new user stories, and ensure every task maps back to a high-level business goal.
Reviewing team throughput or capacity planning. You use this MCP to check velocity trends across multiple sprints and track resource allocation.
What Changes When You Connect
Instant KPI checks: Instead of digging through reports to find the velocity number, ask for sprint_kpis and get an immediate read on team health. This is huge during standups.
Full lifecycle view: Need to see how a new feature (an epic) translates into actionable tasks? You can list epics and then drill down through user stories and tasks using the available tools.
Multi-workspace oversight: The all_sprints tool lets your agent check status across every project in your portfolio, which is critical for executive reporting without switching tabs.
Deep historical analysis: Don't just know if you finished; know how. Use the sprint_reports function to pull data needed for burndown and burnup charts immediately.
Structured planning: Quickly set up the next cycle using create_sprint. Then, prompt your agent to list backlogged items so you can assign them right away.
Task status clarity: Need to know which tasks are stuck? Run a query that uses list_tasks filtered by a specific sprint and status to pinpoint bottlenecks.
See it in action
The Product Owner needs to justify the next quarter's budget.
Instead of compiling data from three different boards, ask your agent: 'What were our key performance indicators (sprint_kpis) and overall velocity trends across the last four sprints?' The agent aggregates all sprint_metrics and delivers a ready-to-present summary.
The Scrum Master is running a complex retro meeting.
You prompt: 'Show me the full report on Sprint 13, including member distribution and type breakdown.' The agent uses sprint_reports to deliver everything needed for discussion—who did what, and which parts of the backlog were hardest.
The Engineering Manager needs to check resource capacity.
You ask: 'What is the current progress (sprint_progress) and total task count for the Auth Module sprint?' The agent uses get_sprint combined with list_tasks, giving you a definitive, real-time number.
The PM is onboarding a new feature into the roadmap.
You prompt: 'List all epics in the Payments domain and suggest user stories for the first sprint.' The agent uses list_epics to find the scope, then prompts you to use create_user_story to start populating the backlog.
The honest tradeoffs
Checking progress by listing tasks.
Manually running list_tasks and filtering the spreadsheet yourself is slow. You might miss which sprint period the task belongs to, or forget to check the status column entirely.
Don't manually sift through lists. Ask your agent to use sprint_progress or run a query that combines list_tasks with the specific sprint ID to get an immediate percentage and count.
Assuming all sprints are in one place.
You only look at the current project board, but you need historical data from the old 'Web Portal' team cycle. You waste time manually searching through archives.
Use all_sprints first. It gives a portfolio-level overview of every sprint that ever ran in your organization, helping you find what you need fast.
Trying to get a roadmap from raw data points.
You pull individual list_epics results and try to piece together the timeline. It's messy and doesn't show dependencies or planned sequencing.
Ask your agent to use list_epics in combination with a prompt that asks for suggested user stories, which helps structure the work logically.
When It Fits, When It Doesn't
Use this MCP if your primary need is synthesizing operational data into actionable insights. You want your AI client to act like a highly knowledgeable team member who has access to every dashboard and can instantly compare historical performance (sprint_stats) against current goals (sprint_progress). Don't use it, however, if you are only trying to store structured data or build a custom visualization layer that requires direct database manipulation. For pure reporting, if your goal is generating raw charts for an external BI tool (like Tableau), those dedicated tools might be better. But if the goal is 'answer this question,' use this MCP.
Questions you might have
How do I check progress on multiple projects? (all_sprints) +
You use the all_sprints tool to get a consolidated view of every sprint across all your workspaces. This is essential for portfolio-level oversight when you need to compare different teams' performance side-by-side.
What kind of reports can I generate using sprint_reports? +
The sprint_reports tool generates several types of data, including the information needed for burndown charts, burnup charts, and task type distribution. This gives you a full picture of effort versus completion.
How do I get all user stories in the current project? (list_user_stories) +
Running list_user_stories pulls every story from the backlog for that project. This is your starting point when you need to scope out a new feature or update the roadmap.
Can I see all tasks assigned to one sprint? (list_tasks) +
Yes, using list_tasks and filtering by the sprint slug is the way to go. This shows you every task associated with that cycle, allowing you to check status or identify bottlenecks.
What details must I provide when running the `create_user_story` tool? +
You need to specify a title, detailed description, and optionally link it to an existing epic. This action immediately adds the story to the project's backlog for review.
What information can I retrieve about a single item using the `get_task` tool? +
The get_task tool requires a unique UUID and returns all associated details. You get the task's current status, assignee, estimated effort, and its parent story or epic.
Before planning, how does `list_epics` help me see the full scope of a project? +
It provides an overview of major project containers. Instead of navigating through hundreds of individual stories, you can list all epics to grasp the overall structure and planned features.
What parameters must I provide when calling the `create_sprint` tool? +
You must define a unique name for the sprint, along with a clear start date and an end date. The MCP uses this information to correctly set the boundaries for all related tasks.
Can my AI agent show me the burndown chart data for the current sprint? +
Yes! Use sprint_reports with the resource set to 'burndown'. Your agent returns the ideal versus actual burn-down data points, so you can visualize or analyze sprint health instantly. You can also request 'burnup', 'performance', or 'member_distribution' reports.
Can I see what tasks are in a specific sprint? +
Absolutely. Use list_tasks with the sprint_slug filter to see only tasks belonging to that sprint. You can further filter by status (todo, in-progress, done) to focus on what matters. Then use get_task to drill into any specific task for full details.
Does this integration support sprint velocity and metrics tracking? +
Yes. Use sprint_metrics for detailed velocity, throughput, and efficiency data. Combined with sprint_kpis for high-level indicators and sprint_stats for task distribution analysis, you get a complete performance picture across any sprint.
We've already built the connector for GitScrum Sprints. Just plug in your AI agents and start using Vinkius.
No hosting. No infrastructure. No complex setup.
All 15 tools are live and waiting.
You're up and running in seconds.
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.
Built, hosted, and secured by Vinkius. You just connect and go.