The flow match is the work: driving openLCA without replacing it

Your BOM has a row that reads “stainless steel, 304, hot-rolled, China.” openLCA has a flow that reads almost the same. The gap between those two strings is where a calculation goes wrong, and where an auditor stops you. You lose an afternoon scrolling the provider list, comparing system models, deciding whether the China dataset is close enough or whether you reach for a proxy. The model is fine. The engine is fine. The matching is the work.

Nobody automates this part well, because done honestly it isn’t a lookup. It’s a judgment: which of fourteen LCA databases holds the closest fit, scored on which dimensions, and defendable to whom.

Where openLCA stops and the matching starts

openLCA models. It builds the product system, runs the LCIA against the impact method you pick, and hands you the contribution tree. None of that is the bottleneck. The bottleneck sits one step earlier, at the flow: a real procurement line on one side, a database entry on the other, you in the middle deciding whether they are the same thing.

You know the failure modes. A 304 row matched to a generic “steel, unalloyed” flow. A China input quietly served a European average because the regional dataset was harder to find. A cut-off dataset and an APOS dataset mixed in one system because the metadata was three clicks deep. Each passes the calculation. None passes review.

Which narrows what an “AI emission factor matching” tool has to do: close the gap between the BOM item and the database entry without hiding the decision it made to get there.

Cortex drives openLCA; it does not replace it

Cortex does not reimplement the calculation engine. It connects to and operates openLCA. You keep working in openLCA.

Concretely, Cortex Cowork operates openLCA across the whole workflow. It matches the background datasets, builds the product system, runs the LCIA with the impact method you choose, and pulls back the contribution tree so the emission hotspots show. The engine is the model. Cortex is the operator. The same pattern holds for brightway and 积木LCA, which Cortex also drives; SimaPro and GaBi it complements.

The gap it closes is the flow match itself: a real-world BOM item on one side, an LCA database entry on the other, matched in place — no export, no second application, no copy-paste of a GWP100 value across a window boundary, and no decision hidden along the way.

Cortex does not replace the calculation engine — it drives it. You keep working in openLCA.

What “matched” actually returns

A matcher that returns one answer is not auditable. You can’t defend a number handed to you with no alternatives.

Cortex returns top-k, not top-1. For a flow, you see the candidate datasets ranked, each carrying its GWP100 value, unit, geographic region, system model, source record, and a DQI score across five dimensions: Temporal, Geographic, Technology, Completeness, Reliability. The cut-off dataset and the APOS dataset arrive labelled, never silently merged. The China candidate and the European proxy sit side by side, the regional deviation named. You pick. The pick, and the reason for it, lands in the reasoning chain.

That is the whole audit argument. A confidence score tells you the model was sure. A DQI score across five named dimensions tells your verifier why a dataset fits — temporally, geographically, on production route, on modeled-flow coverage, on source provenance. One of those is reviewable. The other is a black box with a percentage on it.

Where it stops on purpose

Automation that never pauses is automation you can’t file behind. Cortex pauses where it would otherwise break an audit, and hands the decision back.

It pauses when coverage drops too low across your rows to call the match confident. It pauses when the closest dataset is a proxy, not an exact fit, and the substitution needs a justification you’ll have to defend. It pauses when the same material returns factors that differ by more than 2× across databases, because that spread is a question, not a number. It pauses on a restricted dataset it can’t read, rather than slipping a literature value in behind your back.

At each, you decide. The decision is recorded in the reasoning chain, dataset record and deviation note attached. That’s the difference between a tool that does your matching and a tool that does your matching and leaves a trail you can walk back when the auditor asks about row 47.

What you keep

You keep openLCA. You keep your impact method, your product system, your contribution tree. What changes is the afternoon you used to lose on the flow-matching: the parallel search across fourteen databases — HiQLCD, Ecoinvent, EF, CarbonMinds, and others — a DQI score per candidate, the proxy flagged instead of buried, the system model preserved instead of mixed.

This is not certification. Cortex produces a reasoning chain; you file. It aligns with ISO 14067 and the EF method at the data layer, and stops where verification begins — because verification is the verifier’s act.

The matching was always the work. It can be the work that leaves a record.

---

Ask Cortex about a flow, and keep working in openLCA. The engine stays yours.