We Tried to Build One Engine. We Needed Three.

The Illusion

A field is a field. It has a value, or it doesn't. If it doesn't, the agent fills it. If it does, the agent improves it.

Simple. Elegant. Wrong.

The Tension

We started with one field: meta_title.

Product meta titles are often bad: too short, missing the brand name, stuffed with SKU fragments. An AI agent should be able to evaluate a meta title, propose a better one, and deploy the fix. So we built that.

It worked. The agent scanned catalogs, flagged weak titles, generated improved versions citing Google Merchant Center standards, and presented them as patches for approval. Clean.

Then we tried to extend it to every field in the catalog. About halfway through, we realized we were looking at three fundamentally different problems pretending to be the same thing.

The Turning Point

Type A: Optimization Fields. These are fields where a value already exists, but the quality is poor. Titles, descriptions, meta descriptions, alt text. The agent rewrites, restructures, enriches. It has the raw material. It's improving what's already there.

Type B: Gap-Fill Fields. These are fields where the value is missing, but the answer is inferrable. The product doesn't have a "color" attribute, but the title says "Navy Blue Compression Sleeve." The agent extracts structure from unstructured data. It's not generating. It's reading.

Type C: Knowledge-Required Fields. These are fields where the value is missing and cannot be inferred. GTIN is a 14-digit number assigned by GS1. You can't generate one. Country of origin is a supply chain fact. Certifications are legal assertions.

An LLM cannot fill these. A system that tries will hallucinate plausible-sounding values: fake GTINs that pass checksum validation but reference products that don't exist.

The Risk

We tried building one engine that handled all three. It hallucinated GTINs. It skipped hard-to-fill fields. It rewrote titles that didn't need rewriting.

Most AI catalog tools fail silently in exactly this way. They either skip knowledge-required fields entirely (leaving critical gaps) or worse, they fill them with confident fiction.

The first time we deployed meta_title patches, the deploy handler wrote to the database correctly. The audit trail showed the change. But the product detail page showed the old value.

Two bugs, stacked. The frontend wasn't invalidating its cache. And the product detail page didn't know meta_title existed as a renderable field. The data was in the database, the API was returning it, but the UI was silently dropping it.

Neither bug would have surfaced in a unit test. They only appeared when a human clicked "deploy" and then looked at the product. Every layer in the pipeline is a place where a field can silently disappear.

The Principle

Three types of problems. Three types of solutions. One framework that makes each one a known pattern instead of a one-off build.

For optimization fields: detect intent, run quality evaluation, propose improvements, veto changes that are worse than what exists, approve and deploy. Adding a new optimization field means writing a quality evaluator and a proposal generator. The pipeline is shared.

For gap-fill fields: scan against the canonical schema, extract values from unstructured context, assign confidence scores. High-confidence fills auto-approve. Low-confidence fills get human review.

For knowledge-required fields: the agent never tries to fill them. It surfaces them as information requests. "This product is missing a GTIN. Provide the UPC or upload a product sheet." The agent becomes a data collector, not a data generator.

The Future

AI search engines consume structured product data. The richer and more accurate your catalog, the more likely your products surface in AI-generated answers.

But "rich and accurate" means different things for different fields. For titles and descriptions, richness means quality. For colors and materials, richness means completeness. For GTINs and certifications, accuracy means truth.

You can't build one system that handles all three well. We tried. It doesn't work.

The framework isn't complexity for its own sake. It's the minimum viable structure for treating each field the way it actually needs to be treated.

Meta titles taught us the optimization pattern. Colors taught us the gap-fill pattern. GTINs taught us that some things should never be generated.

Three engines. One framework. That's how the system stays honest.