5 Steps to Transform Your Redmine Helpdesk with an AI Plugin

Work on the new RedmineUP plugin, AI Agent, is in full swing. We add new MCP tools to it every week, and the release is just around the corner. In the meantime, our own support team has been working with the plugin, and the results impress us. .

The plugin comes with a built-in MCP server, so an AI assistant can work with your Redmine data directly: read tickets, add notes and build reports. In this article we show what changes in a helpdesk when an AI agent joins the team, one step at a time.

If your team runs support on Redmine, you already own the most valuable input for AI: years of solved tickets, wiki pages, knowledge base articles and customer profiles. Today most of that knowledge is only stored. AI agents let your team, and your customers, actually use it.

RedmineUP support was the first team to put the AI Agent to work on real tickets, and what we saw is the reason for this article. Below, we describe the changes it brings to a helpdesk and the order in which to introduce them.

This is where our approach differs from other AI solutions. All RedmineUP plugins are connected with each other: Helpdesk, CRM, Agile and the rest work with the same tickets, contacts and projects. Because of that, new ideas for small but useful MCP tools reach us every week, and we add them to the AI Agent one by one. These tools, built on the way our plugins work together, will be the main advantage of the AI Agent over other AI solutions.

• Why transform your helpdesk at all
• Step 1: Build a Knowledge Base with Redmine's Wiki
• Step 2: Triage and draft replies
• Step 3: Reports your support team can ask for
• Step 4: A first-line agent that acts
• Step 5: Connect the rest of the business

Why transform your helpdesk at all

AI already pays off in customer support. In its December 2025 report Agentic AI Is the New Frontier in Customer Service Transformation, Boston Consulting Group says one global technology company cut time to resolution for service requests by 50%. Less time spent on each request means lower support costs, and the same team can serve more customers.

There is a catch: only 28% of companies have unlocked measurable business value from generative AI so far. Those that succeed redesign the workflow instead of switching on a chatbot, so this article transforms the helpdesk step by step. The savings show up in numbers you can track from day one: first response time, resolution time, the share of tickets solved without a person and the load per engineer.

In May we wrote that Redmine 7.0 would make your tracker AI-ready. Redmine 7.0 shipped on June 30, 2026 with native webhooks (we covered what's new in Redmine 7), and the Helpdesk plugin exposes tickets and customers through its REST API. The building blocks are in place.

This article shows what the transformation of a Redmine helpdesk looks like in practice, step by step: from an assistant that finds answers in your history to an agent that closes routine tickets on its own. Each step pays off by itself, and each step is gated by numbers, not by hope.

Step 1: Build a Knowledge Base with Redmine's Wiki

The first step is an assistant that answers questions from your own history and shows where each answer came from. Nothing is automated yet, and nothing is sent to customers.

The assistant can only be as good as what it finds, so start with the content. Keep how-to articles and known fixes in the project wiki, and write the resolution into the ticket before you close it.

The approach is called RAG (retrieval-augmented generation). Before the model writes anything, the system searches your Redmine for relevant pages and tickets and gives them to the model. The model answers from what was found and links to it, for example "see ticket #4521 and the wiki page Setting up SSO", so a person can check the source.

How it works with the RedmineUP Agent plugin

1. Search. The agent uses Redmine's own search over wiki pages and issues. There is no separate index to build or keep in sync: a page saved a minute ago is already searchable.
2. Permissions. Every search runs as the user who asked. The agent finds only the projects, issues and wiki pages that person can see in Redmine, so a private ticket from one customer does not end up in an answer for another.
3. Reading. The agent opens the pages and tickets it found and reads them, not just the search snippets.
4. Drafting. The model writes a draft with links to the sources. The draft is placed in the note or description field for review and is never saved automatically.

The plugin also includes an MCP server. Connect Claude, ChatGPT or another MCP client to it and ask about your Redmine in plain language. Each client signs in with OAuth and gets only the scopes an admin has ticked for it.

When keyword search is not enough

Redmine's search matches words. That works well as long as customers and engineers describe a problem in the same terms. On a large archive, or when customers write "cannot log in" and the fix is filed under "SSO certificate expired", the next level is semantic search:

• Split wiki pages and solved tickets into short fragments and turn each one into a vector (an embedding).
• Keep the vectors in a vector database. If Redmine runs on PostgreSQL, the pgvector extension lets them live next to your existing data.
• Use Redmine 7 webhooks to update the index when a ticket is closed or a wiki page changes.

Note: With a separate index, permissions become your job. Store the project and visibility of every fragment, and filter search results by the asking user's permissions before the model sees anything.

Semantic search is a custom project, not a plugin setting. It is worth building once you can see which questions the built-in search fails to answer.

Where teams use it

• Reply drafts. An engineer opens a ticket, clicks the Agent button in the note editor and enters a few key points. The agent reads the ticket, searches the wiki and similar issues, and returns a draft with links.
• Smart search. Through an MCP client, people ask in plain language: "How did we fix the import problem for ACME last year?"
• Onboarding. New team members ask how a process works and get answers from the internal wiki.
• Self-service portal. With a custom integration, customers ask on your portal and get an answer before a ticket is created.

What to measure: how often engineers use the suggested answer, and how often the linked source was actually relevant. This is the data you need for Step 4.

Step 2: Triage and draft replies

In Step 2 the agent starts working on every new ticket: it sorts it, routes it and prepares a draft answer, but a person still sends every reply.

In the Helpdesk plugin, every ticket is a regular Redmine issue. The issue webhook fires the moment an email becomes a ticket, and your agent service (a script or a workflow connected to Redmine through the REST API or the MCP server of the AI Agent plugin) goes to work:

1. It loads the ticket and the customer: GET /helpdesk_tickets/.json?include=journal_messages returns the ticket with its contact and the email thread (docs).
2. It picks a category, priority, product and assignee only from the values that exist in your Redmine, plus the language and the customer's mood.
3. It uses the Step 1 search to find similar solved tickets and writes a draft reply.
4. It saves the fields and adds the draft as a private note in one call to the regular issues REST API.

PUT /issues/4812.json
{
  "issue": {
    "category_id": 7,
    "priority_id": 4,
    "assigned_to_id": 23,
    "notes": "AI triage: billing, EN, customer frustrated (3rd ticket this month). Similar: #3310.\n\nDraft reply:\nHi Anna, thanks for the details. The duplicate charge on invoice #1045 ...",
    "private_notes": true
  }
}

Note: Your support team may handle different customer segments. Each segment generates its own set of requests — payments, troubleshooting, feature requests, downtime, and so on. An agent service can triage and prioritize these requests, and for a ticket under an SLA (such as downtime) it can send an extra notification via Slack or Telegram. As a result, you'll get increasingly precise answers over time.

The engineer opens a ticket that is already sorted, edits the draft and sends it the usual way with Send note checked. A note without that checkbox is visible only to your team, so the customer never sees an unreviewed draft. If you already run your support queue on a board, the sorted tickets land in the right columns of your Agile helpdesk automatically.

Rules that keep it safe

• Closed lists. Pass the model the exact IDs of your categories, priorities and agents, and reject any other answer.
• No auto-send yet. In this step the agent service only writes private notes through the regular issues API. It never calls the Helpdesk reply endpoint, so nothing goes out by email.
• No loops. The agent's own update fires another webhook. Subscribe to ticket creation only, or skip events by the bot user.

Note: Gate to Step 4. Run in this mode for 2 to 4 weeks and log every draft. For each category, record how often the engineer sent the draft with no or minor edits. That number decides where automation is safe.

Get the Helpdesk plugin

Step 3: Reports your support team can ask for

In Step 3 the agent works for the people who run support. It turns your helpdesk history into answers for managers and still sends nothing to customers, so it is a safe step before any automation.

Built-in reports answer the questions someone thought of in advance. With an AI assistant connected to your Redmine through the MCP server of the AI Agent plugin, a support lead can describe the report they need in plain language, and the assistant builds it from Helpdesk data: the query, the numbers and the charts.

For example: "Show first response and resolution time for the RedmineSaaS project: median and P90, the share of tickets answered within 4 hours, how many were solved with a single reply, and how first response time changed over the years."

The result is a working report, not a one-off answer:

• Headline numbers that matter for support: median and P90 first response, answered within 4 hours, median resolution time, one-touch resolution.
• Distributions, not just averages. They show the long tail: the tickets that wait more than 48 hours or stay open for weeks.
• Trends over time, so you can see whether a new process or the AI agent actually moved the numbers.
• Filters by project, period and interval, which the team can change and re-run.

Then the agent explains what it sees: which customers or categories drive the slow tail, where first response time spikes, and which recurring questions deserve a knowledge base article. That turns a report into a to-do list for the next week.

Note: AI-built reports use the same Redmine permissions as everything else. A manager sees the projects they can access in Redmine, and nothing more.

Step 4: A first-line agent that acts

In Step 4 the agent resolves part of the incoming tickets on its own, but only in the categories where Step 2 proved it right.

Note: Step 4 is still being designed. What we build, and when, depends on the test results of Steps 1 to 3.

What the agent does

• Reads requests from the channels the Helpdesk plugin collects: email and the Helpdesk widget. Messengers such as Telegram can be added with a custom integration that creates tickets through the Helpdesk API.
• Answers typical questions from the knowledge base, using the Step 1 search, and replies through the Helpdesk API (POST /helpdesk/email_note.json, docs).
• Performs simple actions through APIs: checks an order or license status, sends a download link, extends a trial.
• Hands the ticket to a person when it is unsure or the request is unusual, with a short summary: "The customer already tried A and B; the likely cause is C."

Roll it out in three stages

1. Drafts only. This is Step 2. It builds the accuracy statistics for every category.
2. Auto-reply in narrow categories where accuracy is proven: password resets, "where is my invoice", "how do I install".
3. Expand category by category, each time based on the numbers.

Always hand over to a person when

• the agent's confidence is low or the question matches no known category;
• the customer is upset, or writes about refunds, legal issues or a security incident;
• the customer is marked VIP or has a premium SLA;
• the customer replies that the answer did not help. Then the ticket goes to a person with the full history.

Routine questions get an answer in minutes, day and night, and your engineers get more time for the problems that need them.

Step 5: Connect the rest of the business

In Step 5 the agent sees the whole customer, not just the ticket: contracts, invoices, SLA, monitoring alerts and past conversations from the systems around Redmine.

Customer story

With the CRM and Helpdesk plugins, one call returns most of the picture: GET /contacts/.json?include=notes,issues,deals (docs). The agent turns it into the story of a customer: who the person is, their company and role, ticket history, open deals and a health score.

Here is a real example. An AI assistant connected to Redmine through the MCP server reads the correspondence with a customer and adds tags to the contact card: industry, country, position in the company and so on. Nobody fills in these fields by hand: the assistant saves the tags with the contact tool of the CRM plugin, within the permissions of the user who connected it, so you can filter contacts and build segments by them right away.

We are now working on how to separate access rights, so that the agent shows each person only the customer data they are allowed to see in Redmine. Once this is done, you will be able to:

• get a short brief about a customer in seconds;
• see the customer's LTV;
• segment customers automatically;
• turn the customer story into a case study.

Compute the score and LTV in code from clear rules, such as ticket trend, open urgent tickets, the mood recorded in Step 2, deal stage and overdue invoices. Then let the model explain it in plain words. The number stays reproducible, and the explanation tells people what to do. See how DataCycle combined CRM and Agile to get a single view of their clients.

What you need to get started

The AI Agent plugin requires Redmine 6.1 or higher and Ruby 3.2 or newer. If your Redmine is older, this is a good reason to update: you get a current, supported version of the tracker, and the Redmine 7 webhooks that the steps below rely on.

If the upgrade causes trouble, send us a message. Our team of experts will check your Redmine environment and recommend the best course of helpdesk AI transformation.

Join the pilot group

In the near future we are forming a group of customers who work closely with Helpdesk and want to improve their support metrics in the same way: faster first response, shorter resolution time and fewer routine tickets for engineers. If this sounds like your team, write to us and we will tell you how to join.