Turn semi-structured text into typed data — without a per-request LLM.
Texomy compiles a domain specification into a deterministic parser. You describe what the text means once; extraction runs at native speed, with the same output every time, and an artifact your team can review.
LogEntry:
$fields:
timestamp: Timestamp
level: LogLevel
service: Service
message: '.*'
$patterns: '#{timestamp} #{level} #{service} #{message}'
LogLevel:
$flags: 'WORD_BOUNDARY'
Info: 'INFO'
Warn: 'WARN'
Error: 'ERROR'
Service:
$flags: 'WORD_BOUNDARY'
Payments: 'PaymentService'
Auth: 'AuthService'
Timestamp:
$fields:
date: { $patterns: '\d{4}-\d{2}-\d{2}' }
time: { $patterns: '\d{2}:\d{2}:\d{2}' }
$patterns: '#{date}T#{time}Z'2025-11-04T09:12:44Z ERROR PaymentService gateway timeout on TX-88213{
"LogEntry": {
"timestamp": { "date": "2025-11-04", "time": "09:12:44" },
"level": { "Error": "ERROR" },
"service": { "Payments": "PaymentService" },
"message": "gateway timeout on TX-88213"
}
}Semi-structured text is everywhere — and nothing handles it well.
Webhooks, log streams, invoices, statements, clinical notes, financial sentences. The shape is real, but not a formal schema. Two options are usually on the table, and both are bad:
- Hand-written regex zoos. Cheap to start, unmaintainable at scale, invisible to domain experts.
- Per-request LLM extraction. Expensive, non-deterministic, hard to audit, drifts silently.
Texomy takes a third path: describe the domain once, compile it, and every matching record becomes typed JSON — deterministically, forever.
Sweet spots in a real product
Ingest normalization
Convert every incoming webhook, email, or upload into typed JSON at the boundary. Downstream never touches raw strings.
LLM pre-processor
Peel off the structured parts of a message deterministically; hand only the genuinely free-form residue to the LLM. Cost and latency drop with structure.
LLM extraction retrofit
Sit in front of an existing GPT-based extractor. Same output contract, near-zero marginal cost, gradual and reversible migration.
Rule & alert engines
Replace a thicket of Splunk/ELK regexes with one spec. Rules are written against a typed model, not raw log lines.
Compliance & audit
The spec is a file you can review, sign off, and hand to auditors. LLM behaviour is not.
Feature engineering for ML
Text → typed features → downstream model. Deterministic features are essential for reproducible training and scoring.
AI writes the spec. The spec runs without AI.
Semantic modelling is creative work — naming domain concepts, choosing what to capture, deciding what recurs. That is exactly the kind of task large language models are good at. So Texomy embraces AI at authoring time: an LLM proposes the specification, a domain expert reviews it, and the compiler turns it into a parser.
At runtime, the LLM is not called. Extraction is a compiled pass over the input. The same record always produces the same result, at native speed, at effectively zero marginal cost.
When the LLM proposes changes to the spec, an accumulated set of YAML test cases replays first — silently catching regressions before anything reaches production. The loop is safe by construction.
Try it in 60 seconds.
Studio is a browser playground with one-click imports of every example on this site. No install, no signup.