AI uses for records
One case, two problems: how a multi-issue support dataset keeps both
By SourceX Editorial · Updated
9 sections
Short answer
A multi-issue support dataset gives every distinct problem in a case its own record, with the rule that governed it, the agent's action and a verified end state, while the customer, account and conversation sit in one shared block. The best-known public multi-intent benchmarks cannot supply this: in MixATIS and MixSNIPS, every multi-intent utterance splits cleanly into stand-alone sentences, so no request relies on another for its meaning.
Evaluation split
Multi issue support dataset
Key takeaways
- Give each problem its own issue record, with rule, action and verified end state, and keep customer, account and conversation in one shared block.
- A single case label hands one problem's outcome to the other, which teaches models to fix the first problem and close.
- All 13,383 multi-intent utterances in MixATIS_clean and all 34,998 in MixSNIPS_clean split exactly into stand-alone single-intent source sentences.
- In the original ATIS files, 41 of 5,871 utterances carry two or more labels; dependent two-problem cases have to come from real histories.
- Score issue recall, per-issue outcomes and an all-resolved case rate together, with codes for missed issues, false splits and context breaks.
When does one support case hold two problems?
A case holds two problems when the customer needs two outcomes that are reached by different actions and confirmed in different systems. A double charge and a broken export are two problems even when they arrive in one email, because the first is settled in billing and the second in the product. A multi-issue support dataset records each outcome as its own issue while keeping the conversation, customer and account they share in one place.
Three look-alikes should stay whole. Two symptoms of one root cause, such as a failed payment and the account suspension it triggered, are one problem with a causal chain, and splitting them counts the same fix twice. A question and its follow-up about the same request are one problem. A second contact about a problem that has not changed is a repeat contact, which belongs to case grouping rather than to issue splitting.
The decision this article supports is whether a support history can be labeled issue by issue without losing the context that made the issues solvable, and what evidence each issue needs. The evidence is the same for every issue: the policy or procedure that governed it, what the agent did about it, and the state the relevant system reached afterward.
Why a single case label hides half the outcome
One category, one resolution code and one status can describe only one of the problems, so the other inherits a label it never earned. When the billing problem is fixed and the export problem is not, the case closes as solved. When the customer returns about the export, the whole case reopens and the billing fix starts to look like a failure. Either way, one outcome disappears from the data.
Models trained on those labels pick up a habit: fix the first problem, then close the conversation. Evaluations built on the same labels reward the habit, because a grader scoring the case as one unit cannot tell an agent that solved both problems from one that solved the easier half and signed off warmly.
Medical administration has written rules for exactly this distinction. The FY 2026 ICD-10-CM Official Guidelines for Coding and Reporting, published by CMS, give separate subsections to two or more interrelated conditions that could each be the principal diagnosis and to two or more diagnoses that equally meet that definition. How the conditions relate decides which rule applies. A support dataset needs the same discipline: every problem recorded, and a stated rule for how the problems in one case relate.
Public multi-intent data is stitched together: a decomposition test
The best-known public multi-intent datasets were assembled by joining single-intent sentences, so every request inside them stands on its own. The AGIF paper (Qin and colleagues, 2020) describes building MixATIS and MixSNIPS by connecting sentences with different intents through conjunctions such as "and". We tested how literally that holds in the cleaned versions the authors recommend.
The test, run on the AGIF repository at commit 6a4b26b, tries to rewrite every utterance with two or more intent labels as a sequence of complete single-intent utterances from its source corpus (ATIS or SNIPS, all splits), separated only by joiners of one to three tokens drawn from a comma and the words "and", "then" and "also", with exactly one segment per labeled intent. All 13,383 multi-intent utterances in MixATIS_clean and all 34,998 in MixSNIPS_clean passed, and in every one the segments' own source labels matched the utterance's labels. The first joiner was always a comma, "and", "and also" or "and then".
The source corpora tell a different story. In the ATIS files shipped in the same repository, 41 of 5,871 utterances carry two or more labels, and the SNIPS files carry none. The BlendX authors (2024) criticized these MixX sets on related grounds, describing them as too simple because single-intent utterances are joined with a small set of conjunctions, and built blended alternatives.
For a support team the lesson is practical. A model that learned multi-issue handling from stitched data has learned to find seams, and real two-problem cases have none: the second problem is often caused by the fix for the first, refers back to it with a pronoun, or depends on an account fact mentioned once. Those cases can come only from real histories labeled issue by issue. The counts:
| Dataset in the AGIF repository | Utterances | Two or more intents | Split exactly into stand-alone source sentences |
|---|---|---|---|
| MixATIS_clean | 14,749 | 13,383 | 13,383 (100%) |
| MixSNIPS_clean | 44,173 | 34,998 | 34,998 (100%) |
| ATIS, the single-intent source | 5,871 | 41 | Not tested: source corpus |
| SNIPS, the single-intent source | 14,484 | 0 | Not tested: source corpus |
Split, link or keep together: matching the structure to the pair
Choose the structure from how the two problems relate, and record which rule you applied. Ticketing tools already provide the parts. GitHub lets a parent issue hold sub-issues nested up to eight levels deep, with a progress field that shows how many are complete, and Freshdesk's parent-child ticketing splits one ticket into child tickets that different agents can work at the same time. What the tools leave to the team is the rule for when to use them.
At a glance
Split, link or keep together: matching the structure to the pair
Five relationships cover most pairs:
- Independent problems, such as a double charge and an unrelated export failure: one case, two issue records, each with its own action and end state.
- Dependent problems, such as an export that fails because the plan downgrade used to fix the charge removed the export feature: two issue records plus an ordered link from cause to consequence, so a grader sees that the first resolution created the second problem.
- One root cause with two symptoms, such as a failed payment and the suspension it triggered: one issue record that lists both symptoms and resolves when the cause does.
- The same problem raised again in a new contact: no new issue; link the contact to the existing case as a repeat.
- A problem the agent raised, such as an expiring card noticed during the call: an issue record flagged as agent-raised, so it is not scored as something the customer asked for.
The issue-level record: what stays shared and what splits
Keep one shared context block per case and one record per issue that points to it. Shared fields hold what is true of the whole conversation; issue fields hold everything that can differ between problems, starting with the outcome.
This packet is illustrative, and the company is invented. A customer of a software vendor writes: "I was charged twice this month, and since your update I can't export my reports." The agent refunds the duplicate charge, which billing confirms the next day, and replies with a help-center article about exports. The ticket is set to solved, but the export keeps failing, and five days later engineering links a bug report to the account. A case-level label calls this solved. The issue-level record shows one of two problems resolved:
| Field | Shared context | Issue 1: duplicate charge | Issue 2: export failure |
|---|---|---|---|
| Customer and account | One pseudonymous customer ID, one account, one plan | Inherited from the shared block | Inherited from the shared block |
| Problem statement | The full message, both sentences | Span: charged twice this month | Span: cannot export reports since the update |
| Rule in force | Account terms on the contact date | Duplicate-charge refund policy | Known-defect escalation procedure |
| Agent action | One reply covering both | Refund issued | Help-center article sent |
| Verified end state | None set at case level | Refund settled next day, per billing | Still failing; bug linked on day 5 |
| Label | Case: one of two issues resolved | Resolved | Unresolved: wrong action for a defect |
Grading rubric: score each problem, then the case
Grade the issues first and derive the case result from them, never the reverse. The case score that matters is whether all issues were resolved, and it should sit beside the issue-level resolution rate so a reader sees both numbers.
Two failures exist only in multi-issue data and need their own codes: a missed issue, where the agent never acknowledged one of the problems, and a context break, where the agent asked the customer to restate account facts already given for the other issue. A third code, the false split, catches graders who turn one problem's two symptoms into two issues and credit the same fix twice.
The rubric runs at two levels:
| Check | Level | Question | Failure code |
|---|---|---|---|
| Issue recall | Case | Did the agent acknowledge every problem the customer raised? | Missed issue |
| Issue precision | Case | Was any issue invented, or one problem split into two? | False split |
| Action fit | Issue | Was the action the one the governing policy or procedure calls for? | Wrong action |
| End state | Issue | Did the relevant system reach the expected state within the window? | Unresolved |
| Dependency order | Case | Was a cause handled before the problem it creates? | Order error |
| Context reuse | Case | Did the agent use facts already given instead of asking again? | Context break |
| Case result | Case | Are all issues resolved? | Partial case |
Could closure or a happy reply stand in for issue outcomes?
No, because a closed status and a thank-you are single signals and a two-problem case has two outcomes. The customer in the packet may well thank the agent for the refund, and that thanks says nothing about the export. Closure is weaker still, since agents often set it as soon as the first problem is fixed.
The strongest version of the alternative is an empirical claim, and it can be tested. If, in a given queue, nearly every multi-issue case ends with all of its issues resolved or none of them, a case label loses little. Before relying on that, double-grade a sample of multi-issue cases issue by issue and count how often the issues inside one case end differently. Where that rate is low and stable across issue types, a case label may serve for that queue; where it is not, issue-level labels are the only honest ones.
Held-out tests a seam-finder cannot pass
Build the test so that habits learned from stitched data fail it. Include dependent pairs, second problems that refer back with a pronoun, and cases where the customer raises the second problem only after the first is resolved. Score issue recall and per-issue outcomes separately, and report the share of cases where a model resolved one issue and then closed the conversation.
Hold out by account and by pair of issue types, so a model cannot pass by recognizing a familiar combination such as billing plus sign-in. When a sample has to be drawn, make it reproducible: rank cases by a keyed hash of the case ID, publish the key and the rule, and anyone holding the same records can draw the same sample.
The limits are real. This article shows that the most-used public multi-intent sets cannot supply dependent problems; it does not measure how often real support cases hold two problems, how often their outcomes diverge, or whether issue-level training makes an agent better. Those numbers have to come from graded real histories.
Writing a multi-issue requirement for a data supplier
Ask for histories in which each issue, not just each ticket, can be traced to an action and a verified end state. That means keeping parent and child links, merges and splits, the systems where each issue's outcome lives (billing, product telemetry, engineering trackers) and the rule used to separate issues.
SourceX works from the buyer's requirement outward, looking for U.S. businesses whose records can meet it; nothing is held in stock waiting for a buyer. A useful request states the issue types in scope, how issues should be separated, the systems that must confirm each end state, the share of multi-issue cases needed and an acceptance test, such as issue-level agreement between two graders on a held-out sample. Fit is judged company by company.
Frequently asked questions
What is a multi-issue support dataset?
It is a set of support cases in which every distinct customer problem has its own record, with the governing policy, the agent's action and a verified end state, while the customer, account and conversation are stored once and shared. It lets a model be trained and graded on each problem instead of on the case as a single unit.
Can MixATIS or MixSNIPS teach a support agent to handle multi-issue cases?
They can teach a model to separate intents joined by a conjunction, but not to handle problems that share facts. In our test, every multi-intent utterance in both cleaned sets split exactly into stand-alone single-intent sentences, so neither contains a second request that relies on the first for its meaning.
Should a ticket with two problems be split into two tickets?
Split the outcome records, not the conversation. Keep one case with a shared context block and give each problem its own issue record and end state. Splitting the conversation itself forces later readers, and models, to reassemble context the customer gave once.
How should an agent that fixed one of two problems be scored?
Score each issue on action fit and verified end state, then report the case as partial. Show the issue-level resolution rate next to the share of cases with all issues resolved, so a one-out-of-two pattern is visible instead of averaged away.
When should two problems be recorded as one issue?
When they are symptoms of one root cause that a single fix resolves, such as a failed payment and the account suspension it caused. Record both symptoms in one issue, so a grader does not credit the same fix twice.
Sources
- The AGIF paper describes building MixATIS and MixSNIPS by connecting sentences with different intents through conjunctions such as "and". Source
- The AGIF repository ships ATIS, SNIPS, MixATIS_clean and MixSNIPS_clean; its README gives the cleaned split sizes, and the files were analyzed for this article. Source
- BlendX (2024) describes MixX multi-intent sets as too simple because they join single-intent utterances with a small set of conjunctions, and builds blended alternatives. Source
- The FY 2026 ICD-10-CM guidelines have separate subsections for interrelated conditions that could each be principal and for two or more diagnoses that equally meet the principal definition. Source
- GitHub sub-issues break larger work into tasks under a parent issue, nested up to eight levels. Source
- GitHub projects offer Parent issue and Sub-issue progress fields showing how many sub-issues are complete. Source
- Freshdesk parent-child ticketing splits a ticket into child tickets that different agents can work on at the same time. Source
Tell us what data you need
Share scope, volume, format, timing and licensing needs. Datasets are sourced on request.