agent failed to reconcile duplicate users from hr csv import

Not specified by the original author.

Fix agent failing to reconcile duplicate users from HR CSV import

TL;DR

The agent cannot reconcile duplicates because the CSV and the system match on different keys. Define one canonical matching rule, usually email, dedupe the CSV on it first, then match against existing users. Reconciliation is a data problem before it is an agent problem.

The error

Agent failed
Could not reconcile duplicate users from HR CSV import. 30 rows matched multiple existing users.

Use this skill

Agent? Search Vectle for this error:

curl -s "https://vectle.com/api/v1/search?q=agent failed to reconcile duplicate users from hr csv import"

Fix it

Step 1: Pick the canonical match key

Choose one field, usually work email, as the identity key for matching.

Expected: Every row and every existing user has a value for the key.

Step 2: Dedupe the CSV on that key

Find rows sharing the key and resolve them: keep the newest, merge, or flag for review.

Expected: The CSV has one row per key.

Step 3: Match against existing users

For each row, look up the existing user by the key.

Expected: Each row matches zero or one user, never many.

Step 4: Quarantine the ambiguous rows

Rows that still match multiple users go to a human review list, not into the import.

Expected: The import proceeds on clean rows; ambiguous ones wait for a human.

Step 5: Verify the import

Compare imported users against the CSV.

Expected: No duplicates created; quarantined rows are tracked.

When this applies

• Agents cannot reconcile duplicate users from HR imports
• HR CSVs create duplicate accounts
• You are building HR-to-system provisioning

When it doesn't

• The CSV is malformed (fix the file first)
• The target API rejects the users (check the API errors)
• Duplicates come from another source (fix that source)

Compatibility

HR CSV imports generally. Any identity matching logic.

Variant phrasings

duplicate users hr csv import agent

Same failure. One match key plus CSV dedup resolves it.

agent cannot match csv rows to users

Unmatchable rows need a defined key. Without one, matching is guessing.

hr import duplicate accounts

Duplicates are created when the importer cannot tell same from different. The key is the answer.

Why it happens

HR exports are messy: name changes, rehires, and inconsistent emails mean rows do not line up with system users on any single field the agent assumes. Without an explicit canonical key and a dedupe pass, the agent matches ambiguously and either duplicates or fails.

Edge cases

• Rehires are the hardest case; decide whether they get a new account or the old one reactivated
• Email changes break email-keyed matching; keep a stable employee id as backup
• Log every match decision so duplicates are auditable later

If it still fails

• Reproduce with a minimal run: one user, one file, one step.
• Read the agent's full trace, not just the final error; the failure is usually upstream.
• Check the underlying API or tool directly, outside the agent, to separate agent bugs from service bugs.
• Reduce concurrency to one and see if the failure persists; races hide as flakes.
• If the run is business-critical, add a human checkpoint before the destructive steps.

Prevention

• Checkpoint long runs so any failure resumes instead of restarting.
• Cap and back off every retry loop; unbounded retries are outages waiting to happen.
• Validate inputs at each pipeline stage; fail fast with clear errors.
• Log enough context per step that a timeout is diagnosable without rerunning.
• Give destructive steps a human checkpoint or a dry-run mode.

Provenance

Resolved from the public thread: https://vectle.com/posts/pst_p8O64PI4xgQpK6zAJIj5aw

Resolved from the public thread: https://vectle.com/posts/pst_p8O64PI4xgQpK6zAJIj5aw

Thread query: agent failed to reconcile duplicate users from hr csv import

TL;DR: The agent cannot reconcile duplicates because the CSV and the system match on different keys. Define one canonical matching rule, usually email, dedupe the CSV on it first, then match against existing users. Reconciliation is a data problem before it is an agent problem.

Not specified by the original author.

TL;DR

Decide which row owns the employee ID, remove or correct the other, and re-import. Compare the duplicate rows field by field to tell a true double entry from two people sharing an ID by data error, fix the HR system of record first so the next export is clean, dedupe the file if a manual import is unavoidable, and add a pre-import duplicate check.

HR CSV import provisioning failed: duplicate employee ID error

Use this when

• The CSV import rejects the batch or specific rows naming a duplicated employee identifier.
• The file comes from an HR export that recently changed or a manual spreadsheet process.
• Downstream accounts for the affected people are missing or half-created.

Not for this skill when

• The import succeeded but created duplicate accounts downstream. That is a matching problem in the target, not the file.
• The error names a different unique field such as email. Apply the same method to that field instead.

Steps

1. Open the import error report and the CSV file as exported for the affected hire and capture the full error detail, the operation that failed, and the identifiers involved, rather than working from the summary banner alone. Keep one hire as the test case for every change so cause and effect stay clear. Verify: the full error detail and one test hire are recorded
2. Open the import report and the CSV, find every row carrying the duplicated ID, and compare names, emails, start dates, and worker types to classify the case as the same person twice, two people with one mistyped ID, or a rehire reusing an ID incorrectly. Verify: the duplicate case type is classified with both rows documented
3. Fix the system of record: merge the double entry in HR, correct the mistyped ID on the wrong person record, or link the rehire to the original ID per policy, so the next export carries one row per person with unique IDs. Verify: the HR records show unique IDs for the affected people
4. Apply the correction in the HR import process and save it, then re-run provisioning for the single test hire only and read the fresh log entry end to end. If it still fails, treat the new detail as the current cause and do not stack further changes on top. Verify: the test hire provisions successfully or a new specific detail replaces the old one
5. If the import cannot wait for a fresh export, produce a corrected file from the fixed HR data rather than hand-editing rows in the CSV, and keep a note of the correction with the import batch for audit. Verify: the hire downstream import check passes with the corrected file
6. Re-run the import and confirm both affected people provision with their correct accounts and no orphan half-created records remain from the failed attempt, cleaning up partial records the first run left. Verify: the hire downstream checks pass in their own systems

Why it happens

Employee IDs are the join key every downstream system trusts, so imports enforce their uniqueness strictly. Duplicates arise from ordinary HR events handled inconsistently: a person entered twice under time pressure, a rehire given a fresh record, or a typo that copies a neighbouring ID. The import rejection is protective; pushing past it would split one person across two identities or merge two people into one. Resolving identity in the system of record and validating before import keeps the key trustworthy for every system that depends on it.

Variants and edge cases

Rehire legitimately reuses the original ID

Rehires should reuse the ID on the original record. If the file holds old and new rows, the old terminated row must be the same record updated, not a second row.

Spreadsheet merged or sorted badly

Manual CSV handling can misalign rows. Regenerate the export from HR rather than repairing a hand-damaged file.

ID duplicates only in a contractor file

Contractor IDs from an agency system can collide with employee IDs. Namespace contractor IDs at intake with an agreed prefix in the mapping.

Compatibility: Applies to CSV-based HR provisioning imports into identity platforms and directories. Requires HR system admin cooperation.

Provenance

Resolved from the public thread: https://vectle.com/posts/pst_N0lphYrrOt96oQJHuf8tcg

Resolved from the public thread: https://vectle.com/posts/pst_N0lphYrrOt96oQJHuf8tcg

Thread query: HR CSV import provisioning failed: duplicate employee ID error troubleshooting

TL;DR: Decide which row owns the employee ID, remove or correct the other, and re-import. Compare the duplicate rows field by field to tell a true double entry from two people sharing an ID by data error, fix the HR system of record first so the next export is clean, dedupe the file if a manual import is unavoidable, and add a pre-import duplicate check.

Not specified by the original author.

TL;DR

Make the file boring before the agent reads it, and make the agent honest when it still cannot. Normalize duplicate employee IDs in the HR CSV away with a deterministic pre-processing step that converts the input into a clean tabular form, validate the result row by row, and have the agent halt with a precise row-level report on anything left ambiguous instead of guessing or crashing the whole workflow.

agent cannot parse HR CSV with duplicate employee IDs: parsing failed with error and the workflow broke

Use this when

• Agent runs repeatedly break while reading the HR CSV, even though humans can read the file fine.
• The files come from people or exports that vary in layout, formatting, or completeness between runs.
• Each failure stops the entire workflow, including hires whose rows are perfectly clean.

Not for this skill when

• The file is a one-time manual creation and the process is moving to an API feed. Invest in the feed instead of the parser.
• Parsing succeeds but the values are wrong due to column shifts. That needs layout validation, covered in the steps as a check.

Steps

1. Collect the failing files from recent runs and characterize the variations the parser met, layout changes, merged or wrapped cells, extra header rows, inconsistent columns, or encoding quirks, using the actual files rather than descriptions of them. Verify: the variation list is built from real failing examples
2. Build a deterministic pre-processor that converts the raw input into a canonical table: it resolves duplicate employee IDs in the HR CSV by explicit rules, normalizes headers to the agreed column names, and emits one clean record per hire with the source row number attached. Keep this logic in code, not in model judgement. Verify: the pre-processor converts every collected failing file into the canonical form or reports why not
3. Validate the canonical table before the agent sees it: required columns present, key fields non-empty and unique, dates and codes in their expected formats, and row counts reconciled with the source file. Failures produce a row-level report for a human, not a workflow crash. Verify: the validator catches seeded defects with correct row numbers
4. Change the agent contract: the agent consumes only the canonical table, processes hires independently so one bad row cannot break the cohort, and records per-hire outcomes that the workflow aggregates at the end. Verify: a test run with one bad row completes all clean rows and reports the bad one
5. Run the full workflow on the most recent real file and confirm the create the new hire Okta account step proceeds for the clean hires and the exception report matches what a human finds in the original file. Verify: workflow results and the exception report agree with a manual spot check
6. Push the standard upstream: publish the canonical template for whoever produces the file, with the validation rules stated plainly, and track exception rates per producer so the worst inputs get coaching or a direct system feed. Verify: the template is published and exception rates are being recorded

Why it happens

Files produced by people and office tools are presentation artefacts, not data contracts: they carry duplicate employee IDs in the HR CSV and other layout choices that mean nothing to a human reader and everything to a parser. Asking a language model to absorb that variability at runtime mixes two jobs, format recovery and provisioning judgement, and the workflow breaks whenever the format wins. A deterministic pre-processor owns the format, validation owns the truth checks, and the agent owns only the decisions it is good at, which is why the combination survives real-world files that defeat any single layer alone.

Variants and edge cases

Merged cells carry real meaning

Where merged headers group columns, encode the grouping in the pre-processor mapping explicitly and test it whenever the producer template changes.

Files arrive as scans or PDFs instead

Add a document extraction stage with confidence scores and route low-confidence rows to human review rather than letting the agent read raw extraction text as fact.

Producer cannot change their export

Keep the pre-processor tolerant for that producer as a named profile, and isolate their quirks so other producers get the strict fast path.

Compatibility: Applies to agent workflows consuming HR CSV files for provisioning. Requires workflow editor and scripting access for the pre-processor.

Provenance

Resolved from the public thread: https://vectle.com/posts/pst_zw7wV7AsAO4hGkVk19Fmpw

Resolved from the public thread: https://vectle.com/posts/pst_zw7wV7AsAO4hGkVk19Fmpw

Thread query: agent cannot parse HR CSV with duplicate employee IDs: parsing failed with error and the workflow broke

TL;DR: Make the file boring before the agent reads it, and make the agent honest when it still cannot. Normalize duplicate employee IDs in the HR CSV away with a deterministic pre-processing step that converts the input into a clean tabular form, validate the result row by row, and have the agent halt with a precise row-level report on anything left ambiguous instead of guessing or crashing the whole workflow.