Skip to main content
Adobe Employee
Nov 12, 2026 4:07 AM UTC

How we use CX Enterprise Coworker's Data Validation Skill

I asked Coworker to check our AEP data. It confirmed what I suspected.

Most data quality problems don't break your pipeline. They slip right through it. The batch succeeds. The schema validates. The dashboard loads. Everyone moves on, and the data is still wrong.

These are the issues that cost the most because nobody notices them right away. Nothing fails. A segment is slightly smaller than expected, a journey reaches the wrong audience, or someone in a reporting meeting asks, "Why does this number look strange?" By then, the bad data may have been flowing for weeks. I recently found a better way to investigate these issues early, and it came from a place I didn't expect: data validation in CX Enterprise CoWorker.

 

The problem nobody writes a rule for

Most of us already have ingestion checks, and they're good at what they do. They answer the questions we know to ask:

  • Is the field populated? Required-field and null checks catch missing data.
  • Is the format correct? Type and pattern checks catch malformed values.
  • Did the records arrive? Volume and freshness checks catch broken or late pipelines.

These checks are essential. But they're deterministic. Someone has to anticipate the failure, write the rule, and maintain it. The harder problems usually don't start as a rule. They start as a feeling:

 "Something about this field looks off."

Maybe an email field is technically populated, but a surprising share of values look like placeholders. Maybe a status attribute contains a value that's valid as a string but doesn't belong to the business process. Maybe an identifier field seems to contain values from a different upstream attribute.

While None of these break the schema though, all of them can break downstream trust.

You can't write a rule for a hunch. Until recently, testing a hypothesis meant writing SQL, walking through nested XDM schemas, profiling values by hand, and spending an afternoon proving yourself right or wrong. That friction is why many hunches never get investigated.

 

What changed in September

In the September 2026 Adobe Experience Platform release, Adobe CX Enterprise Coworker added a Data Validation skill.

The idea is simple: you ask Coworker Chat to validate a dataset or specific fields. The skill analyzes a sample of that dataset and returns the results in the same conversation. It checks the data in two complementary ways.

  1. Statistical checks: what's actually in the field?
    These are deterministic profiling checks: null and missing percentages, distinct-value percentages, the most common values and their frequencies, and high-cardinality detection. The statistical checks give you a factual picture of the field without writing a query.
  2. Semantic checks: does what's in the field make sense?
    This is where it gets interesting. The skill uses the XDM field's name, type, and description to infer what a valid value should look like, then uses LLM-assisted validation to flag values that don't fit. For common data types, it also applies specific checks: email format and domain plausibility, phone readiness for formats such as E.164, and basic ISO-8601 date and timestamp checks.

The second category is what caught my attention. A value can, for example, be a perfectly valid string and still be a terrible email address (if email address was the expected value). It can match the field's datatype and still be obviously wrong to anyone who understands what the field is for. The schema won't catch that. Semantic validation might.

That combination of hard statistics and probabilistic interpretation is what makes the skill useful for investigation.

 

How I used it in Adobe-on-Adobe

I work on Adobe's own Experience Platform implementation as part of Adobe-on-Adobe. Because Adobe runs its own business on AEP, our teams are often among the first to use new capabilities against real production data. As described in How We Run the World's Biggest AEP Implementation with Coworker, this is a large environment, which means data quality issues can be subtle and costly to trace manually.

I ran the Data Validation skill against a couple of our datasets while troubleshooting upstream data issues.

I didn't go in blind. I already had a hypothesis about what might be going wrong and knew which data patterns I was looking for. What I needed was a fast way to determine whether those patterns were present before investing more time in a deeper investigation.

Coworker confirmed them.

I didn't write a query or navigate the schema tree. I named the dataset and the fields I cared about, and I got back a structured view of what was in them, including values the skill considered questionable and why.

That's what made it particularly to me: it shortened the distance between a hunch and evidence. It didn't replace my understanding of the data or the source systems. It gave me a faster starting point for the investigation.

The workflow and examples below illustrates my approach. Feel free to to try this on your own datasets.

 

Step 1: Start with a hypothesis, not an audit.

It's tempting to ask Coworker to "check everything." Resist that, at least at first. You'll get much more value by starting with the field you already distrust and the question you're trying to answer.

For example:

Validate the email field in dataset "[your dataset]"

or

Validate fields "[field A]", "[field B]" in dataset "[your dataset]"

You can also validate a dataset without naming fields, and the skill will select fields automatically. That's useful for exploration, but for troubleshooting a known issue, naming the fields keeps the results focused.

Tip: Include the word "dataset" before the dataset name. Adobe's documentation notes that this helps Coworker identify the dataset correctly.

 

Step 2: Read the evidence, not just the score.

For each validated field, Coworker returns a table row with:

  • Field name, path, and type, so you can confirm you're looking at the intended field
  • % valid, % distinct, and % null across the sampled values
  • Top 5 distinct values and their frequencies
  • Top 5 invalid values, each with an explanation such as "not a valid email format"
  • An additional insight summarizing the field's quality in plain language

When you validate a single field, you also get a chart view. Coworker also suggests next-step prompts, and you can download the results table as CSV.

It's easy to focus on the valid percentage, but the most useful information is usually in the values themselves.

Top values reveal defaults and dominant placeholders. Invalid values and their explanations show why something looks wrong. A high null percentage on a field you expected to be populated can point to a mapping or source-extraction issue. Read these signals together; they tell a more useful story than any single score.

Tip: Start with the Top 5 invalid values. They're usually the fastest route to the root cause.

 

Step 3: Confirm the scope.

The skill analyzes a sample of the dataset, not every record. That's what keeps it fast, but it also means the results should be treated as strong leads, not final conclusions.

Once something looks suspicious, use Query Service or your existing validation tooling to measure how many records are affected, when the issue started, and which sources or batches are involved. That evidence will determine how urgent the issue is and who needs to be involved.

It's also worth remembering that semantic validation is probabilistic. An unusual value may be legitimate for your business, and a plausible-looking value may still be wrong. Clear field descriptions in your schema help the skill make better inferences, but your team's domain knowledge remains the final check.

 

Step 4: Trace it upstream.

The skill is read-only. It doesn't change records, schemas, or mappings. Coworker helps you find and understand the symptom; resolving the cause is still an engineering task.

Compare affected records with the source data, then trace them through the transformation and mapping logic. Look for where the value is introduced or where the expected value is lost: a source-system default, a transformation rule, an incorrect field mapping, or an upstream change nobody communicated.

Then fix it at the source through your normal engineering process. Patching the symptom downstream may make the dataset look cleaner, but the issue will return with the next batch.

 

Step 5: Turn the hunch into a rule.

This is the step that turns one investigation into lasting value.

Once you've confirmed an issue, write a deterministic check that would have caught it. Add it to your existing ingestion validation so the same problem fails loudly next time instead of silently entering production.

The pattern is simple: semantic validation helps you discover the question. Your pipeline should enforce the answer. Over time, your hunches become rules, and your checks become more complete.

 

The bottom line

Most data teams have a short list of fields they quietly don't trust: the ones that "usually look fine," the ones with an old mapping nobody wants to touch, or the ones behind a dashboard number that never quite adds up.

Pick one.

Run the skill against it. Read the values, not just the score. Confirm what you find, trace it to the source, and turn it into a rule.

You'll probably confirm something you already suspected. The difference is that now you'll have evidence for it, and a clearer path to fixing it.

Ingestion tells you the data arrived. Validation tells you whether to trust it.

 

📖 Reference Docs: Validate your Experience Platform data with Coworker

💬 Your turn: What's the one field in your AEP instance you trust least? Share it below, along with what you'd want Data Validation to check.