About

Check the data work. Keep the rule.

Latentmachine is a browser-based suite of developer tools for working with structured data after AI, scripts, or humans have touched it. The core loop is simple: verify whether every transformed row followed one deterministic rule, then infer the rule you can inspect, reuse, or export when something needs to be fixed.

No language model. No server calls. No account. The entire engine runs in your browser, and the source ships unminified so you can read it in your developer tools.

The Problem

The way structured data gets reshaped has changed. You paste a batch of records into a language model, describe the shape you need, and get clean-looking output back in seconds. The shape is right. The field names are better. The first rows pass a glance. That glance is the problem: LLM transformations rarely fail loudly. They fail by being almost consistent — row 27 capitalizes a status the others lowercase, row 93 keeps an empty string where every other row uses null, row 144 writes the date in a different format because the source value looked unusual. Spot-checking the top of the file is exactly how that drift survives into the database.

Checking every row by hand defeats the purpose of using AI. Asking a second model to review the first replaces one probabilistic step with two. What the check actually needs is what the transformation was supposed to have all along: one deterministic rule that either explains every row or names the rows it cannot.

And the older version of the problem has not gone away. Every integration between two systems still has a transformation step — a webhook payload becoming a database record, a spreadsheet export becoming an API payload, an XML feed becoming clean JSON for an import. The gap is a function you write, test, forget about, and rewrite when the source format changes. Writing a script is reliable but slow for one-off jobs. Visual mapping tools fall apart with nested structures, type conversions, and arrays. Query languages like jq and JSONata are powerful but have a learning curve that punishes you exactly when you are in the middle of something else.

Latentmachine covers both halves. Paste the original records next to the transformed records, and Verify checks whether one rule explains the whole batch — flagging every row that breaks it. Show a before-and-after example, and Infer builds the deterministic rule you can inspect, reuse, and export. The result is a verified program — not a guess, and not another model's opinion.

The Tools

Verify

The primary check. Paste original records and the AI output side by side. Verify infers the majority transformation rule and flags every row that deviates from it. Built for catching LLM output drift, verifying migration scripts, auditing manual conversions, and finding the one inconsistent row in a batch of 200.

Infer

The rule builder. Paste structured data on the left (what you have), paste the desired shape on the right (what you need). The engine compares the two, infers the simplest transformation rule, diagnoses any issues, and lets you export the result as code. It accepts JSON, XML, CSV, TOML, YAML, .env, and SQL INSERT as input, and exports JSON, XML, CSV, TOML, YAML, or .env in any supported cross-format combination.

Regex Builder

Provide strings that should match and strings that should not. The engine synthesizes a verified regular expression with named captures, multi-flavor output (JavaScript, PCRE, Python, Java), and a plain-English explanation. It refuses to show unverified patterns and asks for more examples when the evidence is ambiguous.

jq Builder

Paste JSON and click the values you want, or show the desired output shape. The engine generates a verified jq expression with JSONPath equivalents where possible. For the 80% of jq use cases where you know what you want but do not want to write the syntax.

Trace

Trace profiles unfamiliar structured data, explains its shape and patterns, surfaces evidence-backed observations, and compares record sets with safe single or compound keys. The insight-first experience is stable.

How It Works

Verify and Infer both follow the same program synthesis pipeline. The engine parses each input-output pair into a format-agnostic structure, generates candidate operations for every structural difference, validates each candidate against all examples (exact match required), scores them by simplicity using a Minimum Description Length cost model, and selects the cheapest program that fits.

Before returning a result, it runs a diagnosis pass for contradictions, ambiguous mappings, missing fields, and unseen values. The diagnosis is not an afterthought — it is the product. The output should be useful, but the check and the rule should be trustworthy.

What It Can Infer

• Field mapping, renaming, removal, nesting, and flattening.
• String cleanup, concatenation, splitting, case changes, and template-style merges.
• Type conversion between strings, numbers, booleans, and common date formats.
• Value maps that stop safely when an unseen value appears.
• Numeric operations, binary math between fields, and basic unit conversions.
• Array projection, extraction, filtering, counting, joining, and element lookup.
• Cross-format translation between JSON, XML, CSV, TOML, YAML, .env, and SQL INSERT (input only).

The Diagnosis

Most transformation tools optimize for producing output. Latentmachine optimizes for telling you when it should not.

If your examples contradict each other, the engine identifies the conflicting examples and the specific field. If two rules fit equally well, it reports both interpretations and suggests what kind of additional example would distinguish them. If the new input contains a value the engine has not seen in any example, it flags the field instead of guessing. If a required source field is missing, it warns before producing output.

Each diagnosis comes with a specific next step. Not "something went wrong" but "add an example where this field has a different value." Two or three rounds, and the engine is willing to say "safe."

What It Does Not Do

Latentmachine is for structured, repetitive data translation. It does not handle free-text rewriting, natural language instructions, language translation, external lookups, arbitrary business logic, database queries, or transformations that depend on information outside the input data. If the transformation requires runtime state, multi-step logic chains, or information outside the input data, write the function yourself.

Who It Is For

People checking AI output

You asked ChatGPT, Claude, or another model to reshape a batch of records and need to know whether every row followed the same transformation. Paste the original records and the AI output into Verify, find the drift, then use Infer when you want to replace the inconsistent step with a deterministic rule.

Automation builders

You use n8n, Make.com, or another automation platform and need a Code node between a webhook trigger and the next step. Paste the payload your trigger produces, show the shape your next node expects, and export the inferred rule as a ready-to-paste snippet.

Developers integrating APIs

You are connecting a payment processor to a database, syncing a CRM to a mailing list, or normalizing responses from multiple APIs into one internal format. Use examples to infer the glue code between nested JSON, flat CSV rows, YAML configs, XML feeds, and composed operations.

People migrating or cleaning data

You are moving records between a CMS and an import system, and the fields have different names, different nesting, different types, and trailing whitespace. Show the source record and the clean target record, and the engine infers the cleanup rule — trim, title-case, type-coerce, split, and restructure — in one step.

Anyone who does not want to learn jq today

You know which fields you want from a JSON payload. You can see them. The jq Builder lets you point to them instead of writing the syntax.

Exports

Once a rule is marked safe, Latentmachine can copy the translated output, download in any output format (JSON, XML, CSV, TOML, YAML, or .env), copy the symbolic rule program, or export code:

• Standalone JavaScript — a dependency-free transform() function.
• n8n Code — a snippet using $input.all(), ready to paste into a Code node.
• Make.com JavaScript — a snippet using inputData for Make.com modules.
• Standalone CLI — a single file you run from a terminal, CI pipeline, or cron job. Includes the transformation, input validation, guardrail checks, a diagnostic report, and a baked self-test. No dependencies. No internet.

// Latentmachine inferred transformation
// Status: safe | Confidence: proven (5/5 checks)
function transform(input) {
  return {
    name: `${input?.user?.first ?? ""} ${input?.user?.last ?? ""}`,
    accountId: input?.account?.id,
    logins: Number(input?.login_count ?? 0),
  };
}

Beyond the Browser

The browser tools are the demonstration. The engine itself is a standalone, zero-dependency artifact that runs anywhere JavaScript runs. The developers page documents the live MCP/HTTP endpoint and the implemented npm package, local MCP server, and CLI release targets.

The MCP surface is the interesting one. Point Claude Desktop, Claude Code, Cursor, or any other MCP client at latentmachine.com/api/mcp and Verify becomes a tool the agent can call on its own output — a deterministic check inside the loop, at the exact moment the AI has just transformed your data. No key, no account, no state.

Where It Came From

Latentmachine started as an experiment with ARC — the Abstraction and Reasoning Corpus, a benchmark from AI research designed to test whether systems can learn new rules from a few examples without pretraining. The challenge: look at a handful of input-output grid pairs, figure out the underlying rule, and apply it to a new grid. No training data. No learned weights. Just structured search and discipline.

Building a solver for that problem required a specific set of primitives: perceive structure, generate hypotheses, validate against evidence, score by simplicity, and refuse to guess when the evidence is insufficient. Those same primitives turned out to be exactly what you need to infer a data transformation rule from before-and-after examples.

The grid-domain engine still exists in the codebase as a research prototype. The data transformation engine was built on the reasoning model that emerged from it. The diagnosis system — contradictions, ambiguity, suggested next examples — came directly from the insight that knowing why a solver fails is as valuable as knowing when it succeeds.

Design Principles

Deterministic. The same examples always produce the same rule. No randomness, no sampling, no temperature parameter. The engine is a pure function.

Inspectable. The symbolic rule is the primary result, not the output. You can read every operation, see which examples support it, and understand why it was chosen over alternatives. The source code ships unminified.

Honest. The engine would rather give you a warning you ignore than an output you should not trust. When the evidence is insufficient, it says so. When two rules tie, it reports both. When a value is unseen, it stops.

Private. There is no backend API, no database, no account system, and no analytics — not even the cookieless kind. The site makes zero measurement calls of any sort. The URL does not change when you paste data. Nothing leaves your machine unless you copy or export it. This is not a promise to take on faith: open the Network tab of your browser and watch.

Free. No paywall, no usage limit, no feature gating. The engine and all four tools are free to use.

Privacy

Latentmachine runs in the browser. Your examples, inputs, outputs, and rules stay on your machine. There is no server-side processing step, no account system, and no telemetry of any kind — not on your data, not on your visit. This is not a policy — it is an architectural decision. The engine has zero runtime dependencies and makes zero network calls during use.

You can paste production data, real API keys, real customer records, and real financial payloads. None of it leaves your device. If the page is already loaded, you can disconnect from the internet and keep working.

Built By

Latentmachine is built by Sandro, a Berlin-based designer, creative developer, and solo builder. The project grew out of a curiosity about the primitive structure of intelligence — what it takes to figure out a rule from a few examples without being told — and a practical frustration with writing the same kind of glue code between systems over and over.

The engine, the tools, the benchmark suite, the articles, and the site are all one-person work. If you have feedback, questions, or find a transformation that should work but does not, reach out on Threads.

Status

Latentmachine is in active development. Verify, Infer, Regex, jq, and Trace are stable and free to use. Trace's existing fingerprint APIs remain compatible, while its insight-first product adds deterministic profiles, evidence, sampling, and safe keyed comparison. The engine supports JSON, XML, CSV, TOML, YAML, .env, and SQL INSERT, tested by a benchmark and acceptance suite that gates every deploy. The same engine runs outside the browser too: the developers page covers the live MCP/HTTP endpoint plus the implemented npm package, local MCP server, and CLI release targets. A detailed case study covers the design decisions. Technical notes are published in the Latentlog.