Saved Successfully.

Coming soon

Fusion Core

AI Diagnostics Across Your Systems

When something breaks, the evidence is rarely in one place. Fusion Core gives approved AI assistants one secure, read-only way to gather diagnostic evidence from across your systems, Webcore applications and your own alike, connect it to the code in your Git repository, and draft a support response that a person checks before it is sent.

One incident, many systems, no single view

Why diagnosis takes so long

A partner reports a failed booking. The cause could sit in the portal, in the API behind it, in a certificate on a load balancer, or in a configuration change made last week in a different hosting environment. Each system keeps its own logs, its own errors and its own access rules, so the first hours of most incidents go on finding the evidence rather than reading it.

AI assistants read evidence quickly, but only if they can reach it safely. Handing an assistant a dozen passwords and a copy of the production logs is not an answer. Fusion Core is.

Coming soon

Fusion Core is coming soon. Register your interest and we will be in touch as it becomes available.

  • Read-only by design
  • Cross-system evidence
  • Git repository link
  • Source code correlation
  • Drafted support replies
  • Fix raised in nucleus
  • Verified fix memory
  • Azure Application Insights
  • Outbound-only log reader
  • Tenant isolation
  • Redaction
  • Full audit

What it is

One secure doorway to your diagnostic evidence

Fusion Core connects to every system an incident touches: Webcore applications through their built-in diagnostic interface, your telemetry in Azure Application Insights, the systems you run yourself through a small log reader, and your Git repository for the code. It sits in front of all of them as a single gateway that approved AI assistants connect to through the open Model Context Protocol.

The assistant asks a bounded question. Fusion Core checks who is asking and what they are allowed to see, fetches only that, and returns redacted evidence labelled with its source, environment and time.

  • One connection for the assistant, instead of one per system
  • Access decided by policy on the server, never by the assistant
  • Credentials held server-side and never shown to the AI model
  • Sources that could not be reached are reported, not hidden
  • Works with any approved assistant that supports the Model Context Protocol

What it does

From scattered evidence to a reviewed answer

Fusion Core does the gathering, the joining up and the first draft, and can hand the fix straight to webcore nucleus. Your team keeps the judgement and every approval.

Across systems

One timeline, many sources

Evidence from each system is brought onto one UTC timeline. Where requests share a trace or correlation id they are joined directly; where they only line up in time, the match is labelled as inferred, with the evidence for it, so nobody mistakes a coincidence for a cause.

Back to the source code

The code behind the error

Link your Git repository and Fusion Core can view the code behind an error at the version that is actually running, returning short excerpts and commit references rather than whole files. Access is read-only and limited to the repositories you approve.

Clear about gaps

Partial answers say they are partial

If a source cannot be reached, or the running version cannot be matched to a commit, the result says so. An investigation is never quietly built on missing evidence.

Guided by runbooks

Reviewed steps for known problems

Versioned diagnostic runbooks set out which reads to make, where the decision points are and who owns the fix, and each case records the runbook version it followed.

Ticket context

Starts from what the customer said

Fusion Core reads the support ticket, so the investigation begins with the reported symptom and its history rather than a guess.

An evidence-backed draft

Diagnosis, fix and how to check it

The draft reply carries the diagnosis, links to the evidence behind it, a suggested remediation and a checklist for confirming the fix worked.

A person sends it

No reply leaves without review

There is no tool that posts a reply. Your support team reviews the draft, edits it and sends it themselves, and the review is recorded against the exact version they approved.

Clear ownership

Who changes what

Where the fix sits in infrastructure your team or your hosting provider runs, the draft hands over the findings and the checks to run afterwards, rather than reaching for the controls itself.

From diagnosis to task

Raised in webcore nucleus

When the cause is in the code, the diagnosis becomes a nucleus task in one step, carrying the evidence, the affected code and the suggested fix, so nothing has to be retyped or rediscovered.

Catalyse prepares the change

An AI coding agent on the task

Catalyse, the coding agent built into nucleus, plans the fix against your linked repository, writes the change and runs the tests, starting from the evidence Fusion Core gathered.

People approve every step

Plan, change, release

Your team approves the plan before any code is written and reviews the change before it is merged and released through your normal process. The agent proposes; people decide.

The loop closes

From incident to verified fix

Once the fix is released and confirmed, the case is recorded in verified memory with the task and the change that resolved it, so the next incident like it starts from the answer.

Verified incident memory

Only what was proven

A resolution enters memory only after a designated verifier records evidence that the fix worked. Drafts and unconfirmed theories stay out of it.

Kept within your tenant

Your history stays yours

When a similar problem appears, the assistant can find the verified fix from your own past incidents, and never from anyone else's.

Correct and withdraw

Memory that stays accurate

A verified case can be corrected or withdrawn when better evidence arrives, so an outdated answer does not keep being offered.

Faster each time

Less starting from scratch

Every verified incident shortens the next investigation, turning one engineer's hard-won fix into something the whole team can use.

Where it reaches

Beyond the application logs, without opening your network

Not every clue sits in an application log. Fusion Core extends the same read-only, policy-checked access to the places the rest of the evidence lives.

Webcore applications

Portals, sandbox, certification, project delivery, service desk and API management products, all read through the same diagnostic interface and the same rules.

Azure Application Insights

Requests, exceptions and dependency calls, read with a read-only identity on your monitoring workspace through bounded, pre-approved queries, and matched to application logs by operation id.

Your own systems

For systems Webcore does not host, a small log reader runs inside your own environment. It searches and redacts at source and connects outbound only, so you open no inbound port.

Your Git repository

Link the repository behind each system. Fusion Core reads the code at the deployed version, read-only, so a diagnosis can point at the change and the line behind it.

Built for trust

Read-only, reviewed and recorded

An AI assistant is only as safe as the access behind it. Fusion Core enforces its rules outside the model, so nothing an assistant reads in a log, a ticket or a file can widen what it is allowed to do.

Your applications keep ownership of their own data. Fusion Core asks for the least it needs, and remembers who asked for what.

  • Read-only: Fusion Core never changes configuration, code or production data itself
  • A person reviews every reply before it is sent
  • Tenant and environment isolation enforced on the server
  • Secrets and personal data redacted before the AI model sees them
  • Instructions hidden in logs or tickets treated as evidence, never as commands
  • A full audit record of every call, allowed or refused

Works with

Across the Webcore product family

Fusion Core is a separate diagnostics platform that reads across the Webcore products. These are the ones it works with most closely.

webcore serviceDesk

The ticket supplies the context for an investigation, and the reviewed reply goes back through the desk your team already works from.

webcore latitude

Sandbox and test traffic is one more source of evidence when a partner's integration misbehaves.

webcore nucleus

A diagnosis that needs a code change becomes a nucleus task, where Catalyse prepares the fix for your team to approve.

Be first to see Fusion Core

Fusion Core is coming soon. Register your interest and tell us where your incidents take longest to diagnose.