Latentmachine

Verify AI Data Transformations

AI transforms data fast. Latentmachine tells you if it got every row right. A deterministic engine that checks consistency, infers rules from examples, and refuses when the evidence is missing. No LLM. Runs in your browser.

Check a batch →

Verify demo Rule verified examples → rule → proof

original record

{
  "first_name": "Ada",
  "last_name": "Lovelace",
  "role": "admin",
  "created": "2024-03-15T10:00:00Z"
}

AI output

{
  "fullName": "Ada Lovelace",
  "role": "admin",
  "joinDate": "2024-03-15"
}

inferred rule

Join first_name and last_name into fullName.
Copy role unchanged.
Format created as joinDate.
Every shown output follows the same rule.

3 example rows checked. No drift found.

Verify

Did the AI get every row right?

Paste the original records and what the AI gave you back. Verify infers the majority rule, applies it across the batch, and flags every row that doesn't match.

Open Verify →

Say you gave an AI 200 customer records to clean up. On most rows it did the same things: lowercased the email, split the name into two fields, turned "yes" into true. Verify reads all 200 before-and-after pairs and works out that pattern, which is the rule the AI was apparently following. Then it re-checks every row against it. Row 137 says "TRUE" instead of true? Flagged. Instead of proofreading 200 rows, you look at the 3 that broke the pattern and you can read the rule to see what the AI actually did.

Verify batch verification

row 1 status → active follows

row 2 status → active follows

row 3 status → active follows

row 4 status → archived review

row 5 status → active follows

verdict majority rule held for 4 of 5 rows 1 needs attention

Infer

Fix what the AI got wrong. Keep the rule.

Show the correct transformation with one or two examples. Latentmachine infers the deterministic rule, verifies it against your evidence, and exports it as code you own. Replace the inconsistent AI step with a rule that always holds.

Open Infer →

Say a webhook sends data in one shape and your database needs another. Instead of writing the conversion code, you paste one example of each: this is what arrives, this is what it should become. Infer compares the two and works out the exact steps that turn one into the other. Rename this field, join those two, turn that string into a number. It lists the steps so you can check them, says so when one example isn't enough to be certain, and hands you finished code that runs anywhere. You showed it what you meant and it wrote the function.

Infer example pair accepted

before

{
  "id": "cus_42",
  "first": "Ada",
  "last": "Lovelace"
}

after

{
  "customerId": "cus_42",
  "fullName": "Ada Lovelace"
}

inferred rule

rename id → customerId
join first + last → fullName
emit owned JavaScript transform

safe · exportable

Regex

Build a regex from yes and no.

Mark strings that should match and strings that should reject. Regex returns a readable pattern verified against every example, or asks for one more when the pattern is under-proven.

Open Regex →

A regex is a search pattern that describes the shape of text "two letters, a dash, then numbers" in a notation almost nobody can write from memory. Here you skip the notation. Paste examples that should match (AB-2041, XY-100) and examples that shouldn't (AB2041, ab-99). The engine works out what separates the two piles and writes the pattern for you. Then tests it against every example you gave. If your examples leave two interpretations open, it doesn't guess; it tells you and asks for one more.

Regex verified pattern

match

555-1234 555-9988

reject

phone 555-12

pattern ^\d{3}-\d{4}$ matches every yes · rejects every no

Select the JSON you want. Keep the jq that finds it.

Click the values you want, or show the shape you need. jq Builder writes the expression, guaranteed to return exactly that, and explains it in plain English.

Open jq →

jq is a small language for pulling values out of JSON, the format most APIs speak. Powerful, but the syntax is its own little learning project. The builder skips it. Paste your JSON and click the values you want: the email buried three levels deep, the price inside a list. The engine writes the jq expression that returns exactly what you clicked from this file or any file shaped the same. You get the expression, a plain-English line saying what it does, and proof it returns what you picked.

jq Builder selection → expression

input.json

{ users: [ { name: "Ada", email: "a@lm" } ] }

.users[]
| .email

returns selected values

explanation walk every user, then return the email field

Trace

Understand your data in seconds.

Paste or import structured data. Trace profiles every field, surfaces missing, unusual, or repeated values, and compares datasets by safe keys. It runs locally and without an LLM.

Open Trace →

Imagine opening a spreadsheet from someone else with thousands of rows and no explanation. Trace gives it a careful first look: what each column contains, which values are missing, what looks unusual, and whether two versions changed. It does not decide whether the data is good or bad. It shows the evidence and points you to the exact fields and records worth checking. Everything stays in your browser.

Trace customers.csv · exact

30 records

7 fields

2 findings

Missing values monthly_spend 1 of 30 records

Unusual value 2,499 median 129

monthly_spend most values 29–269

Worth a look Evidence linked to field and record local · no upload

Deterministic

Same input, same rule. Every check can be replayed.

Client-side

Your data stays in the browser. Nothing is uploaded.

No LLM

A symbolic engine verifies the evidence or refuses. No AI checking AI.

Browser

You're already here. Nothing installs, nothing uploads.

CLI & CI

The prepared CLI checks a batch and exits 0 or 1.

MCP

Point any MCP client at latentmachine.com/api/mcp. Verify becomes a tool your agent can call.

HTTP

Plain JSON-RPC. No key, no account, no state.

Read the developer docs →

Trust, verification, and what the AI missed.

Why LLM batch outputs drift, how deterministic rules catch the rows that broke, and when refusal is the correct answer.

How to verify LLM data transformations LLMs can reshape data fast, but batch outputs drift. Here's how to check every row. When AI gets your data transformation almost right The three specific ways language models fail at structured data, and what deterministic inference does instead. The tool that refuses to guess Why refusal is a feature when data transformations need trust.