agent could not parse the bank memo format and the match loop timed out on 12k lines

TL;DR

Twelve thousand lines timing out usually means every line pays parsing cost before matching starts, and the parser is failing on the real format, retrying or erroring per line. Collect a sample of memos and read their actual structure: position of reference, separator style, check numbers, and reference types. Build the parser for that structure with fast paths for the common shapes and a safe fallback that marks memos unparsed instead of stalling. Matching then proceeds on parsed references plus the original memo text.

agent could not parse the bank memo format and the match loop timed out on 12k lines

Use this when

• The match loop times out specifically during memo parsing on thousands of lines, here 12k.
• Memo formats include codes, separators, or structures the parser does not expect.
• Some lines parse instantly and others hang or error, pointing at format-dependent paths.

Not for this skill when

• Memos are missing or empty on most lines. Then matching must use other fields; parsing cannot be fixed for data that does not exist.
• Parsing succeeds but matching still times out. That is the matching-scale problem, handled by blocking and staging.

Steps

1. Sample a few hundred memos across vendors and days and classify their shapes: reference positions, separators, and token types. Verify: the dominant shapes cover most of the 12k lines
2. Time the current parser on the sample and identify the expensive or failing shapes. Verify: the slow path is tied to specific shapes, not to volume alone
3. Build the parser for the actual shapes with fast exact extraction for the common ones and a bounded, no-retry fallback for the rest. Verify: every sample memo parses or is marked unparsed within a small time budget
4. Run matching on parsed references with the original memo retained as a fallback signal. Verify: match rates improve and no line stalls the run
5. Process the full 12k lines within the time budget with unparsed memos reported as an exception class. Verify: the run completes and the unparsed rate is quantified for the next parser iteration

Variant phrasings

bank memo format parse failed agent match timeout

The unparseable-memo phrasing.

agent transaction memo parser bank reference extraction

When building the parser.

Compatibility: Bank memo and reference formats parsed by agent matching pipelines for 10k-plus line sets.

Why it happens

Bank memos are the bank's idea of a description, not a data format: conventions vary by bank, channel, and even branch, mixing references, codes, and narrative in one string. Parsers written for one bank's format fail on another's, and per-line exception handling that logs verbosely or retries turns a format gap into a timeout. The sample-first approach works because memo formats are stable per bank: learn the real shapes once and the whole set yields.

Edge cases / pitfalls

• Keep the raw memo text through the pipeline; it is the evidence of last resort and the training data for the next parser version.
• Reference positions can shift when banks change memo layouts without notice; a periodic format re-check catches drift.
• Some memos carry check numbers or card tokens that are sensitive in logs; parse them but redact them in job logging.

Provenance

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