AI writes the spec. The spec runs without AI.
Semantic modelling is creative work — LLMs are great at it. Extraction is repetitive, must be auditable, and needs to be cheap. Texomy splits the two, so every part of your pipeline uses the right tool.
Authoring time: AI as co-author
You show an LLM some sample text and describe what you want out of it. The LLM proposes a Texomy specification — types, fields, patterns, cross-references — and you review it in the domain vocabulary, not as regex. Studio makes the loop tight: edit, parse, see the JSON, adjust.
The LLM is not guessing at runtime. It is proposing structure at design time. Its output is a file you can read, commit, diff, and hand to auditors.
Runtime: deterministic, cheap, auditable
The compiled spec parses every input the same way. No API calls, no rate limits, no non-determinism. Extraction cost approaches zero per record, and every production result is reproducible.
Texomy Architect — a Custom GPT that co-authors specs
Texomy Architect is a specialised Custom GPT trained on the Texomy syntax, modelling conventions, and the common antipatterns to avoid. Give it example text; it will propose a specification, iterate on it with you, verify it against your sample, and hand you a one-click Studio link.
The Architect knows:
- How to name and layer types so the resulting JSON reads like a domain model.
- When to promote a value to an enum vs. keep it as an inline pattern.
- How to compose primitives (numbers, dates, IDs) into higher-level shapes.
- Where flags belong, and where they should be scoped or negated.
- How to test a spec against real input before it leaves the conversation.
A public preview — feedback welcome. The Architect uses Texomy Actions to compile and parse specs directly from the conversation.
Where Texomy fits in a pipeline that already uses LLMs
For teams already paying for per-request LLM extraction, Texomy usually sits in front of the LLM. The deterministic, recurring parts of each record are peeled off by Texomy; only the genuinely free-form residue reaches the model.
Over time, the pattern that emerges is a learning loop:
- New text lands. Texomy extracts what the current spec knows.
- Whatever it cannot classify is set aside in a discovery bucket.
- An LLM reviews the bucket periodically and proposes spec changes.
- Every previously successful extraction replays as a YAML test case before the change is merged.
- A domain expert reviews the test diff, not the YAML diff.
- The new spec ships. The pipeline is a little cheaper, a little smarter.
The safety net is the accumulated test set. It is written by nobody — it grows automatically from real traffic that already produced correct output.
Draft a spec with the Architect.
Or start from a blank Studio and iterate manually — either way works.