AI uses for records
Cross-department dataset task boundaries: count each work episode once
By SourceX Editorial · Updated
10 sections
Short answer
Cross-department dataset task boundaries should follow the shared outcome, not each team's system. Group every record the work touched into one episode, then classify each as the outcome owner, a segment, a mirror copy or a separate episode with its own outcome. Count episodes rather than records, mark a handoff only where a system shows accountability moving, and keep every view of one episode on the same side of a train-test split.
Agent run
Cross department dataset
Key takeaways
- One piece of cross-department work usually leaves a record in every system it touched; the shared outcome, not the system, sets the unit.
- The outcome-independence test sorts each record into outcome owner, segment, mirror or spawned episode.
- A handoff needs a system-recorded transfer, ideally with an acceptance event; a mention is not a handoff.
- Assemble episodes from explicit work links and never through customer, product or employee records.
- Count episodes, segments and records separately, and split by episode so no view of one event sits in both training and test.
Where does one piece of cross-department work start and end?
It starts at the request that creates a shared outcome and ends at the event that settles it; every department record in between is a segment of one work episode, not a task of its own. Cross-department dataset task boundaries go wrong when they follow each team's system instead of that outcome.
Take a customer who reports that an invoice charges for cases that never arrived. Support opens a ticket, finance reviews a credit, the warehouse checks proof of delivery and someone clones the ticket into an issue tracker for an operations dashboard. Extracted system by system, that becomes four tasks, each with a partial view and a different closing status. Extracted by outcome, it is one episode: two handoffs, each with a trip back, and one copy that adds no work.
The difference matters three ways. Volume claims inflate, because one piece of work counts several times. The reasoning splits, because the finance record holds the approval and the support record holds the customer's evidence. And evaluation leaks, because a model tested on the support view may already have trained on the finance view of the same event. The method below classifies every record by its relation to the outcome, grades handoff evidence, assembles episodes through explicit work links, and sets counting and splitting rules.
Why every department's system files the work as its own task
Because work tools are built around queues, and a queue needs a record its own team can own, assign and close. When work crosses a department line, most systems create a second record rather than extending the first, and each one closes on its own team's terms.
Zendesk's side conversations show the pattern. A side conversation addressed to another group can create a child ticket that the other team works in its own views, and Zendesk's documentation says child tickets do not inherit other ticket data from the parent: if the parent's status changes, the child's status does not change automatically, and copying fields to a child is a one-time event at creation. It also says there is generally no reverse connection between parent and child. Two records, two statuses, one piece of work.
Issue trackers add copies. Atlassian's support documentation says that when an issue is cloned, Jira attempts to link the original and the clone using a link type configured for the purpose, and that if the setting is unset or names a link type that does not exist, no link is created. A clone without a link is a duplicate that nothing in the data marks as one. Salesforce takes a hierarchical route: its Case object has a ParentId field, labeled Parent Case ID, that places one case under another, which preserves the relationship only if teams use it. The patterns and the trap each sets:
| System pattern | What it creates | Boundary trap | Field to keep |
|---|---|---|---|
| Zendesk side-conversation child ticket | A second ticket owned by another group | Statuses diverge, so the child can close while the work is still open | Parent ticket ID and the side conversation reference |
| Jira clone | A copy of an issue, linked only if the clone link type is configured | An unlinked clone reads as a separate task | The clone link, or the source key written in the copy |
| Salesforce parent and child cases | Cases nested through Parent Case ID | Child cases counted as tasks in their own right | ParentId on every case |
| Email forwarded to another team | A new thread in another mailbox | The forward starts a new conversation with no link back | The forwarded message's original identifiers |
The outcome-independence test: owner, segment, mirror or new episode
Classify every record the work touched by asking two questions. Could this record's own outcome succeed while the shared outcome fails, or fail while it succeeds? And does the record add work, or only copy work recorded elsewhere? The answers sort each record into one of four roles, and each role has its own counting rule.
An episode has exactly one outcome owner: the record whose closure settles the shared outcome, usually the one facing whoever made the request. Segments are steps another team performed that have no outcome apart from the shared one; a credit approval exists only to resolve the dispute. Mirrors add no work at all, such as clones made for reporting or tickets created by a sync rule. A spawned episode is a record whose outcome stands on its own, such as a process change filed because of the dispute, which can succeed or fail whatever happened to the customer's invoice.
The test is about outcomes, not text. Two records written by different teams in different words can be the same episode, and two records with near-identical wording can be different episodes. The four roles, with the treatment each gets:
| Role | Independence test result | Illustrative record | Counts as | Packet treatment |
|---|---|---|---|---|
| Outcome owner | Its closure is the shared outcome | The support ticket closed when the customer accepts the resolution | The episode, once | Anchor; holds the request and the settling event |
| Segment | Adds work; no outcome of its own | Finance's credit-approval child ticket | Part of the episode | Keep the handoff in, the work done and the handoff back |
| Mirror | Adds no work; copies another record | An issue-tracker clone made for a dashboard | Nothing | Drop from the packet; keep in a lineage file |
| Spawned episode | Its outcome can succeed or fail independently | A loading-dock photo requirement filed after the dispute | A separate episode, linked | Reference only; build its own packet if in scope |
What counts as a handoff, and what is only a mention
A handoff is a recorded transfer of accountability: the system shows work assigned to another team, and the receiving team acts on it. A chat message that mentions finance, or a note saying a colleague was consulted, is a mention; it may explain a decision, but nothing moved.
At a glance
What counts as a handoff, and what is only a mention
Process modeling draws a similar line. OMG's BPMN 1.0 specification models separate participants as pools and subdivisions inside a participant as lanes; message flows must connect two pools and cannot connect two objects in the same pool. Departments of one company are lanes, so a transfer from support to finance is a step inside one process, while a message to the customer or a carrier crosses to another participant. For a dataset, that maps to a useful rule: internal transfers become segments inside the episode, and exchanges with outside parties are evidence the episode cites, not segments of it.
Grade every handoff before using it in a label. A transfer with an acceptance event is strong evidence. A transfer with no acceptance is an open handoff, which matters when the outcome went wrong, since the work may never have been picked up. A mention alone is not a handoff and should not be labeled as one. Each handoff record should carry these fields:
- Sending team and receiving team, as recorded by the system, not inferred from names.
- The transfer event and its timestamp: an assignment change, a group change or the creation of a child record.
- What was asked, in the words of the transfer itself.
- The acceptance event and its timestamp, or a marker that none exists.
- The return path: how the result came back, such as a reply into the parent record or a status change.
- The handoff's grade: accepted, open or mention only.
Assembling an episode through work links, not shared customers
Build the episode as a connected group of work objects joined by explicit links, then cut it wherever the independence test finds a separate outcome. Never connect records through shared master data such as the customer account, product or employee, because that merges everything a customer ever did into one blob.
Process-mining research names the problem this avoids. A 2023 review of object-centric process mining by Berti, Montali and van der Aalst notes that the one-to-many and many-to-many relations in enterprise data make it unnatural, if not impossible, to analyze a process through a single, predefined case notion; forcing one produces the issues known as deficiency, convergence and divergence. Convergence is the one that duplicates work: an event gets copied into several cases, such as an invoice event repeated under every order it covers. In a 2024 paper, Adams and van der Aalst argue that only case extraction based on connected components is free of all three issues.
Connected components are only as good as the graph they run on. Put work objects in it (tickets, cases, issues, credit memos, delivery checks) and explicit links between them (parent IDs, child references, clone links, keys quoted in text and confirmed), and the components approximate episodes. Add the customer record as a node and every ticket that customer ever filed joins the same component. Then apply the independence test inside each component, so a spawned episode leaves as its own unit with a reference back.
Worked packet: a short-shipment dispute that crosses four teams
The Illustrative packet below follows a short-shipment dispute at a building-products distributor. A customer emails support that an invoice bills for 40 cases but only 34 arrived. Support opens a ticket and starts a side conversation to finance, which becomes a child ticket. Finance asks the warehouse for proof of delivery, and an operations analyst clones the support ticket into the issue tracker for a weekly dashboard.
The warehouse confirms that six cases were left off the truck, finance approves a credit memo, and support tells the customer, who accepts. Afterward, logistics files a request to require photos at the loading dock. Eight records touched this work; the packet keeps four, references one and leaves three out.
Each record, with its role and the reason for the decision:
| Record | System and role | Handoff evidence | Packet decision |
|---|---|---|---|
| Customer's dispute email and support ticket | Help desk; outcome owner | Request received; closed on the customer's acceptance | Keep; anchors the request and the settling event |
| Finance credit-approval child ticket | Help desk child ticket; segment | Created from a side conversation; finance acted the same day | Keep the ask, the approval and the reply back |
| Proof-of-delivery check | Warehouse system task; segment | Assigned by finance; result posted to the child ticket | Keep the count shipped and its timestamp |
| Credit memo | ERP document; evidence of the segment's work | Linked by invoice number quoted in the child ticket | Keep the memo amount field and date only |
| Issue-tracker clone | Issue tracker; mirror | None; created for reporting | Drop; record in the lineage file |
| Loading-dock photo request | Process change request; spawned episode | Filed by logistics citing the dispute | Reference by ID only |
| Customer master record and other tickets | CRM; master data | Not part of this work | Exclude; the account ID stays a coarse attribute |
| Sales rep's note that the customer is upset | CRM activity; mention | No transfer of work | Exclude; it changes no step or outcome |
Which handoff context did the dispute episode keep?
Most of it, with one gap that matters: the approver's authority. The map below checks, for each handoff, whether the context a reader needs was recorded by a system, stated only in free text, or not recorded at all, and what each status means for the label.
The finance approval is the weak point. The child ticket shows who approved the credit, but nothing records whether that person could approve credits of this size. The label can say a credit was approved; it should not say the approval followed policy, because the packet cannot show it. That is a narrower claim, and an honest one. The elements and their status:
| Context element | Status in this episode | Where it sits | Consequence for the label |
|---|---|---|---|
| What support asked finance | Recorded by system | Side conversation text and child ticket creation | Usable as the handoff ask |
| Finance acceptance and timing | Recorded by system | Child ticket assignment and first internal note | Handoff graded accepted |
| Warehouse result | Stated in free text only | A comment on the child ticket quoting the delivery count | Usable, flagged as transcribed rather than system-written |
| Approver's authority for the credit size | Not recorded | No approval limit in any exported record | Do not label the approval as within policy |
| Return path to the customer | Recorded by system | Public reply on the support ticket | Usable as the settling step |
| Customer acceptance | Recorded by system | Customer reply and ticket closure | Usable as the shared outcome |
Count episodes and split by episode, not by record
Count work by episode and keep every view of an episode on the same side of any split. Records, segments and episodes are three different numbers, and a dataset description that blurs them overstates how much distinct work it contains.
At a glance
Count episodes and split by episode, not by record
Leakage is the larger risk. Kapoor and Narayanan's survey of machine-learning-based science found leakage errors reported across 17 fields and grouped them into a taxonomy of eight types. Duplicated episodes create one route to it: when the support view of a dispute lands in training and the finance view lands in test, the model has seen the outcome before it is asked to predict it, and text deduplication will not catch the overlap because two teams described the same work in different words. Rules that prevent it:
- Report episodes, segments and raw records as separate counts in every volume statement.
- Assign an episode ID before any split, and stamp it on every segment and handoff example.
- Split by episode ID; send a spawned episode to the same side as the episode that produced it.
- Drop mirrors from training and evaluation counts, and keep them in a lineage file so the drop can be audited.
- Withhold every view of an evaluation episode from training, including segments that look unrelated.
- Run text deduplication as well, while treating it as a supplement that cannot find differently worded views.
Would joining every linked record make the work clearer?
No. Beyond the outcome path, extra joins add noise faster than understanding and raise linkage risk with every system added. The useful stopping rule is the outcome path: include a record if it lies on a chain of explicit links between the episode's request and its settling event, or if it holds the evidence for a graded handoff; leave out branches that dead-end without changing a step.
The case for joining more is strongest when the goal is to study how departments interact, since side traffic shows workload and friction. That is a different dataset with a different unit, and it should be scoped and approved as such rather than folded into task packets.
Each extra system also brings more people and more customers into view. A packet that joins the CRM account, the customer's other tickets and every colleague's notes becomes easier to tie back to a specific company or person, even after de-identification. Keeping to the outcome path is a data-minimization choice as much as a modeling one.
Writing episode boundaries into a data request
State the unit as the episode, define the four roles and the handoff grades, and ask for counts at each level. Those few lines turn a vague request for cross-functional records into something a supplier can prepare and a buyer can check.
At a glance
Writing episode boundaries into a data request
SourceX does not keep cross-department records on a shelf; it sources datasets for AI buyers from U.S. businesses once a request arrives, and it carries the licensing company through rights review, contracting, preparation and delivery. Describing episode boundaries in the request tells that preparation what to assemble; it is not a promise that any company's records will fit. Lines for the request:
- Unit: one work episode per shared outcome, with an episode ID on every included record.
- Roles: outcome owner, segment, mirror or spawned episode, with the independence test recorded for each record.
- Handoffs: sending and receiving team, transfer and acceptance events with timestamps, and a grade of accepted, open or mention only.
- Links: explicit parent, child, clone and reference keys only; no joins through customer, product or employee records.
- Counts: episodes, segments and raw records reported separately, with mirrors listed in a lineage file.
- Splits: by episode ID, with spawned episodes kept with their source.
- Acceptance test: a sampled check that reviewers assign roles the same way, with a minimum agreement fixed in advance.
Frequently asked questions
What is a work episode in a cross-department dataset?
A work episode is everything done to reach one shared outcome, such as resolving a customer's billing dispute, across every team and system involved. Department records inside it are segments or copies, so the episode, not each record, is the unit to count and split.
How do you tell a handoff from a mention?
A handoff shows a system-recorded transfer of work to another team, such as an assignment change or a child record, ideally followed by the receiving team acting on it. A mention only refers to another team or person; it can explain a decision but should not be labeled as a transfer.
Why not treat each department's record as its own task?
Most department records have no outcome of their own; they exist to serve the shared one. Counting them separately inflates volume, scatters the reasoning across examples and lets views of the same event appear in both training and test data.
When does a related record become a separate episode?
When its outcome could succeed or fail regardless of the original work's outcome. A process change filed because of a dispute is a common example: link it to the dispute by reference, keep it on the same side of the split, and build its own packet if it is in scope.
Can text deduplication find duplicated episodes?
Only some of them. Clones and synced copies share wording, but two teams describing the same work usually write different text. Episode IDs assigned from explicit links catch the views that text matching misses.
Sources
- Zendesk says side-conversation child tickets do not inherit other ticket data from the parent, that a parent status change does not change the child's status, that field copying happens once at creation, and that there is generally no reverse connection. Source
- Atlassian's support documentation says Jira attempts to link an original issue and its clone through a configured link type, and creates no link when the setting is unset or names a missing link type. Source
- Salesforce's field reference lists ParentId on the Case object, labeled Parent Case ID, as a reference to another case. Source
- OMG's BPMN 1.0 specification models participants as pools and lanes as sub-partitions within a pool, and requires message flows to connect two pools rather than two objects in the same pool. Source
- Berti, Montali and van der Aalst's 2023 review says one-to-many and many-to-many relations make it unnatural, if not impossible, to analyze a process through a single predefined case notion. Source
- Adams and van der Aalst (2024) argue that only case extraction based on connected components is free of convergence, divergence and deficiency issues. Source
- Kapoor and Narayanan's survey of leakage in machine-learning-based science covers errors reported across 17 fields and presents a taxonomy of eight leakage types. Source
Tell us what data you need
Share scope, volume, format, timing and licensing needs. Datasets are sourced on request.