Latentmachine

Verify AI data transformations.

Compare original and transformed datasets, find the records that broke the pattern, and turn the validated transformation into deterministic code.

Verify a batch → Infer a rule

Use AI to explore. Use rules to execute.

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.

One workflow

From uncertain output to a rule you can own.

Verify discovers what happened. Infer turns the correct behavior into a reusable rule.

1

See what the AI actually did

Compare the original and transformed datasets to identify the apparent pattern.
2

Find every inconsistent record

Verify checks the complete batch and attaches evidence to every exception.
3

Lock in the correct transformation

Correct the examples, infer the intended rule, and export deterministic code.

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 Inconsistent

Original records · JSON

[
  { "id": 1,
    "status": "active" },
  { "id": 2,
    "status": "active" },
  { "id": 3,
    "status": "archived" }
]

AI output · JSON

[
  { "id": 1,
    "enabled": true },
  { "id": 2,
    "enabled": true },
  { "id": 3,
    "enabled": true }
]

Verdict

Inconsistent — 1 of 3 rows does not follow the rule.
Rows 1–2 map active → true. Row 3 needs review.

1 row flagged

Infer

Turn validated examples into a deterministic rule.

Correct the inconsistent examples, then let Infer derive a reusable transformation, verify it against your evidence, and export code you can inspect and own.

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 Safe

Input · 2 records

[
  { "id": "cus_42",
    "first": "Ada",
    "last": "Lovelace" },
  { "id": "cus_71",
    "first": "Grace",
    "last": "Hopper" }
]

Expected output · 2 records

[
  { "customerId": "cus_42",
    "fullName": "Ada Lovelace" },
  { "customerId": "cus_71",
    "fullName": "Grace Hopper" }
]

Rule

Set customerId from id.
Join first and last into fullName.

Exact fit · 2 steps

Labs & utilities

Supporting tools for inspecting and expressing transformations.

Regex, jq, Trace, and Signal remain available when the Verify → Infer workflow needs a closer look.

When an inferred rule needs explicit review and approval, Contract Studio carries it into a governed runtime workflow.

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

Signal · Experimental

Find the lines that break the pattern.

Paste a long log, migration report, or technical specification. Signal groups recurring structures, reveals local pattern breaks and concrete constraints, and explains every observation against its source line.

Open Signal →

Signal pipeline-run.log · stream

24 lines 3 templates 1 attention

INFO job <id> completed in <duration>12×

FATAL rollback customer_eventsnew transition

INFO cleanup completedcontext

Why line 19 received attention rare after a repeated completion · contains “rollback”

Deterministic

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

Browser tools · 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

Prepared release target. Batch verification exits 0 or 1.

MCP

Connect a client with remote HTTP MCP support to latentmachine.com/api/mcp.

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.