What if AI
kept its word?

General-purpose LLMs are remarkably good at understanding language. But there's a difference between understanding the rules and being bound by them.

Tell a model not to approve an expense above the spending limit, and it will usually comply. Usually. Not exactly the word you want in an approval system.

So developers build entire systems around the model—validating outputs, retrying failures, enforcing rules and making yet more model calls. What started as one clever API call becomes a whole engineering project just to make its decisions reliable.

We built Blatent Struct to change that.

The idea is programmable AI: give the model freedom to interpret messy language, make decisions and generate responses, while making the requirements it must satisfy enforceable. With JSON Schema and policies, Struct can search for a valid, permitted result rather than simply hoping the instructions were followed. If it can't find one, it returns an explicit failure.

That means less infrastructure to build and maintain, whether you're evaluating expense claims, triaging security incidents or controlling what an AI agent is allowed to do.

The model gets to be clever. Your rules get the final say.

How many “r”s are in “strawberry”? Three. Not exactly rocket science. Yet plenty of fast decision models get it wrong, often with remarkable confidence. And they'll happily return that wrong answer in perfectly valid JSON. Unfortunately, perfectly formatted nonsense is still nonsense.

Struct gets the count right. But counting letters is a modest ambition. Ask it to write a poem whose successive word initials spell “strawberry”, and the same idea becomes more interesting: the words are its choice; the initials are your rule.

JSON solves a real problem: software needs an answer it can parse. A schema goes further, defining fields, types and possible branches. But { "poem": "anything at all" } can be valid JSON and a valid object with a string field. It still tells you very little about the poem.

A policy lets you express what must be true of the result. The initials must match another field. The amounts must add up. The dates must be in order. The proposed action must be allowed for the user making the request.

Struct combines language understanding with JSON Schema and policies written in Rego, the language of Open Policy Agent. Those policies are evaluated against the generated result and the context you supply before a successful answer is returned.

The model can choose the answer.
It cannot choose whether your rules apply.

When a candidate fails, Struct can search for a compliant alternative within your configured budget. If it cannot find one, you get an explicit failure. Your application receives a result it is allowed to use, or a failure it can handle.

Struct makes individual decisions fast. When those decisions become part of a complex workflow, it stays efficient by narrowing the possibilities at each step. More branches don't have to mean more waiting.

We want AI to keep doing extraordinary things. We also want its intelligence to be practical enough to call from ordinary software, thousands or millions of times, with the requirements spelled out in advance.

That's why we built Struct.