Knowledge Management

Your team is resolving the same issues over and over — from memory.

Every service team has hard-won knowledge — how to resolve the recurring WiFi issue, what causes the application error, the steps for the fiddly password reset. That knowledge lives in heads and old email threads, not where it's useful. Vivantio's knowledge management makes it findable, reusable and available at the point of service.

Agent-facing and user-facing. One knowledge base, two audiences.

Vivantio knowledge management — knowledge base with agent-facing article suggestions

Service teams at leading organisations trust Vivantio

The problem it solves

Knowledge in heads and email threads is a retention risk, not a process.

When resolution knowledge lives outside the service platform, it's invisible to new agents, unavailable at the point of service, and walks out the door when experienced staff leave.

  • Same issues resolved from memory — or from scratch — every time
  • New agents depend on experienced colleagues rather than documented steps
  • No self-service deflection because there's nothing to surface to users

Without knowledge management…

The recurring issue is handled from scratch for the tenth time this quarter

New agents learn by watching — and making the same early mistakes

Senior agent leaves and takes half the team's resolution capability with them

What knowledge management does

Capture. Surface. Resolve faster.

Knowledge capture from resolved tickets

Turn resolutions into reusable knowledge — without extra work

The best time to write a knowledge article is immediately after resolving the issue — when the solution is fresh and the steps are in front of you. Vivantio lets agents create an article directly from a resolution: click to create, pre-populate from resolution notes, refine and publish through the approval workflow. Knowledge capture becomes part of the resolution process, not an additional task.

  • One-click article creation from resolution notes on a closed ticket
  • Configurable review and approval workflow before publication
  • Automatic review reminders to keep articles current
Vivantio knowledge management — creating an article from a resolved ticket
Knowledge surfaced at point of service

Agents find answers without leaving the ticket

Vivantio surfaces relevant knowledge articles in the agent workspace while a ticket is open — suggesting known-error resolutions, similar past tickets and related guides based on the ticket's subject and category. Agents don't need to switch to a separate search tool; suggestions appear contextually within the workspace, based on the ticket's subject and category. Used articles can be linked to the ticket for the audit trail and the resolution note.

  • Contextual article suggestions in the agent ticket view
  • Search the knowledge base from within the ticket — no context switch
  • Link used articles to ticket records for audit trail
See how knowledge surfaces in the agent workspace
Vivantio knowledge management — contextual article suggestions in agent workspace
User-facing self-service knowledge

Deflect tickets before they're raised — with articles users actually find

Vivantio's knowledge base serves two audiences: agents resolving tickets and users looking to resolve issues themselves. The same article library powers the self-service portal, with visibility controls separating internal agent-only content from end-user-facing articles. As users type into the portal, relevant articles are suggested inline — deflecting tickets that could be self-served without the team ever knowing.

  • Visibility controls: internal articles (agent-only) vs. user-facing (self-service)
  • Inline article suggestions in the self-service portal at ticket creation
  • Article usage metrics — see which articles deflect the most tickets
See how the self-service portal surfaces knowledge
Vivantio knowledge management — user-facing knowledge base in self-service portal
Recognised by service teams who've made knowledge a process, not an afterthought
Common questions

Knowledge management: what teams ask us

What is ITSM knowledge management?

ITSM knowledge management is the practice of capturing, organising, and making available the knowledge that service teams need to resolve incidents, answer questions, and handle requests consistently. It encompasses agent-facing articles, user-facing self-service content, and the processes for keeping knowledge current. In ITIL terms, the Knowledge Management process supports all other ITSM processes by making verified solutions reusable.

What is the difference between a knowledge base and a service catalogue?

A knowledge base contains articles — how-to guides, known error resolutions, troubleshooting steps — that help users or agents find answers. A service catalogue presents structured request forms for services the team delivers. Vivantio's self-service portal combines both: users can search the knowledge base for answers and browse the service catalogue for requests in the same place.

How does Vivantio help agents build and maintain knowledge articles?

Vivantio makes it easy to create articles directly from resolved tickets — agents click to create an article from the resolution notes without switching context. Articles go through a configurable review workflow before publication. Review reminders flag stale articles for update. Article usage metrics show which articles are actually used, so maintenance effort focuses on high-value content.

Does Vivantio AI assist with knowledge management?

Yes. Vivantio AI Assist can suggest relevant knowledge articles to agents while working a ticket — surfacing known-error resolutions and similar past tickets without the agent needing to search. AI Enrich can identify tickets that represent common patterns where a knowledge article would deflect future volume. The knowledge base is the foundation that makes AI suggestions accurate and useful.

See it in action

Knowledge that gets used — because it's where the work happens.

We'll show you how Vivantio's knowledge management fits your team's resolution patterns and self-service goals — with a demo built around your service environment.

~30-minute demo No commitment Built around your service patterns